From c139d8277e745d82fe7a920d0bf2a2e8cf0abf9d Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Mon, 29 Dec 2025 15:42:28 -0800
Subject: [PATCH 01/49] Feat: add multi language support

---
 backend/config/languages.ts                   | 210 ++++++++++++++
 backend/graphs/conversation-graph.ts          | 260 ++++++++++++------
 backend/graphs/flashcard-graph.ts             |  51 +++-
 backend/graphs/introduction-state-graph.ts    |  78 +++++-
 backend/helpers/anki-exporter.ts              |  31 ++-
 backend/helpers/audio-processor.ts            |  77 +++++-
 backend/helpers/flashcard-processor.ts        |  53 +++-
 .../helpers/introduction-state-processor.ts   |  37 ++-
 backend/helpers/prompt-templates.ts           |  50 ++--
 backend/server.ts                             | 133 +++++++--
 flashcard-graph.json                          |  12 +-
 frontend/index.html                           |  15 +-
 frontend/js/flashcard-ui.js                   |  36 ++-
 frontend/js/main.js                           | 148 +++++++++-
 frontend/js/storage.js                        | 101 +++++--
 frontend/styles/main.css                      |  50 +++-
 package-lock.json                             |   8 +-
 17 files changed, 1138 insertions(+), 212 deletions(-)
 create mode 100644 backend/config/languages.ts

diff --git a/backend/config/languages.ts b/backend/config/languages.ts
new file mode 100644
index 0000000..0ce9e97
--- /dev/null
+++ b/backend/config/languages.ts
@@ -0,0 +1,210 @@
+/**
+ * Language Configuration System
+ *
+ * This module provides a centralized configuration for all supported languages.
+ * To add a new language:
+ * 1. Add a new entry to SUPPORTED_LANGUAGES with all required fields
+ * 2. The rest of the app will automatically support the new language
+ */
+
+export interface TeacherPersona {
+  name: string;
+  age: number;
+  nationality: string;
+  description: string;
+}
+
+export interface TTSConfig {
+  speakerId: string;
+  modelId: string;
+  speakingRate: number;
+  temperature: number;
+  languageCode?: string; // Optional TTS language code (e.g., 'ja-JP')
+}
+
+export interface LanguageConfig {
+  // Identifier
+  code: string; // e.g., 'es', 'ja', 'fr'
+
+  // Display names
+  name: string; // English name: "Spanish"
+  nativeName: string; // Native name: "Español"
+  flag: string; // Emoji flag
+
+  // STT configuration
+  sttLanguageCode: string; // Language code for speech-to-text
+
+  // TTS configuration
+  ttsConfig: TTSConfig;
+
+  // Teacher persona for this language
+  teacherPersona: TeacherPersona;
+
+  // Example conversation topics specific to this language's culture
+  exampleTopics: string[];
+
+  // Language-specific instructions for the LLM (written in English, about teaching this language)
+  promptInstructions: string;
+}
+
+/**
+ * Supported Languages Configuration
+ *
+ * Each language defines everything needed for:
+ * - Speech recognition (STT)
+ * - Text-to-speech (TTS)
+ * - Teacher persona and conversation style
+ * - Cultural context and example topics
+ */
+export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
+  es: {
+    code: 'es',
+    name: 'Spanish',
+    nativeName: 'Español',
+    flag: '🇲🇽',
+    sttLanguageCode: 'es-MX', // Mexican Spanish
+    ttsConfig: {
+      speakerId: 'Diego',
+      modelId: 'inworld-tts-1',
+      speakingRate: 1,
+      temperature: 0.7,
+      languageCode: 'es-MX',
+    },
+    teacherPersona: {
+      name: 'Señor Gael Herrera',
+      age: 35,
+      nationality: 'Mexican (Chilango)',
+      description:
+        "a 35 year old 'Chilango' (from Mexico City) who has loaned their brain to AI",
+    },
+    exampleTopics: [
+      'Mexico City',
+      'the Dunedin sound rock scene',
+      'gardening',
+      'the concept of brunch across cultures',
+      'Balkan travel',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in Spanish
+- Use natural Mexican Spanish expressions when appropriate
+- Vary complexity based on the user's level`,
+  },
+
+  ja: {
+    code: 'ja',
+    name: 'Japanese',
+    nativeName: '日本語',
+    flag: '🇯🇵',
+    sttLanguageCode: 'ja-JP', // Japanese
+    ttsConfig: {
+      speakerId: 'Asuka',
+      modelId: 'inworld-tts-1',
+      speakingRate: 0.95,
+      temperature: 0.7,
+      languageCode: 'ja-JP',
+    },
+    teacherPersona: {
+      name: '田中先生 (Tanaka-sensei)',
+      age: 42,
+      nationality: 'Japanese (Tokyo)',
+      description:
+        'a 42 year old Japanese teacher from Tokyo who loves sharing Japanese culture and language',
+    },
+    exampleTopics: [
+      'Tokyo neighborhoods',
+      'Japanese cuisine and izakaya culture',
+      'anime and manga',
+      'traditional arts like calligraphy and tea ceremony',
+      'Japanese music from enka to J-pop',
+      'seasonal festivals (matsuri)',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in Japanese
+- Explain the difference between casual and polite forms when relevant
+- Introduce kanji gradually with furigana explanations when helpful
+- Mention cultural context behind expressions (e.g., why certain phrases are used)
+- Use romanji in parentheses when introducing new vocabulary`,
+  },
+
+  fr: {
+    code: 'fr',
+    name: 'French',
+    nativeName: 'Français',
+    flag: '🇫🇷',
+    sttLanguageCode: 'fr-FR', // French
+    ttsConfig: {
+      speakerId: 'Alain',
+      modelId: 'inworld-tts-1',
+      speakingRate: 1,
+      temperature: 0.7,
+      languageCode: 'fr-FR',
+    },
+    teacherPersona: {
+      name: 'Monsieur Lucien Dubois',
+      age: 38,
+      nationality: 'French (Parisian)',
+      description:
+        'a 38 year old Parisian who is passionate about French language, literature, and gastronomy',
+    },
+    exampleTopics: [
+      'Parisian cafés and culture',
+      'French cinema (nouvelle vague)',
+      'wine regions and gastronomy',
+      'French literature and philosophy',
+      'travel in Provence and the French Riviera',
+      'French music from Édith Piaf to modern artists',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in French
+- Pay attention to gender agreement and verb conjugation corrections
+- Explain the nuances between formal (vous) and informal (tu) when relevant
+- Share cultural context about French expressions and idioms
+- Mention pronunciation tips for tricky French sounds`,
+  },
+};
+
+/**
+ * Get configuration for a specific language
+ * @param code - Language code (e.g., 'es', 'ja', 'fr')
+ * @returns Language configuration or default (Spanish) if not found
+ */
+export function getLanguageConfig(code: string): LanguageConfig {
+  const config = SUPPORTED_LANGUAGES[code];
+  if (!config) {
+    console.warn(
+      `Language '${code}' not found, falling back to Spanish (es)`
+    );
+    return SUPPORTED_LANGUAGES['es'];
+  }
+  return config;
+}
+
+/**
+ * Get all supported language codes
+ */
+export function getSupportedLanguageCodes(): string[] {
+  return Object.keys(SUPPORTED_LANGUAGES);
+}
+
+/**
+ * Get language options for frontend dropdown
+ */
+export function getLanguageOptions(): Array<{
+  code: string;
+  name: string;
+  nativeName: string;
+  flag: string;
+}> {
+  return Object.values(SUPPORTED_LANGUAGES).map((lang) => ({
+    code: lang.code,
+    name: lang.name,
+    nativeName: lang.nativeName,
+    flag: lang.flag,
+  }));
+}
+
+/**
+ * Default language code
+ */
+export const DEFAULT_LANGUAGE_CODE = 'es';
+
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 9bface7..14afe67 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -7,12 +7,18 @@ import {
   RemoteSTTNode,
   RemoteTTSNode,
   TextChunkingNode,
+  Graph,
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
 import { renderJinja } from '@inworld/runtime/primitives/llm';
 import { AsyncLocalStorage } from 'async_hooks';
 import { conversationTemplate } from '../helpers/prompt-templates.js';
 import type { IntroductionState } from '../helpers/introduction-state-processor.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 export interface ConversationGraphConfig {
   apiKey: string;
@@ -25,90 +31,146 @@ export const stateStorage = new AsyncLocalStorage<{
     messages: Array<{ role: string; content: string; timestamp: string }>;
   };
   getIntroductionState: () => IntroductionState;
+  getLanguageConfig: () => LanguageConfig;
 }>();
 
-export function createConversationGraph(_config: ConversationGraphConfig) {
-  // Create the custom node class that gets state from AsyncLocalStorage
-  class EnhancedPromptBuilderNode extends CustomNode {
-    async process(_context: ProcessContext, currentInput: string) {
-      // Get state accessors directly from AsyncLocalStorage (set before graph execution)
-      const stateAccessors = stateStorage.getStore();
-
-      if (!stateAccessors) {
-        // Fallback to empty state if not available
-        const conversationState = { messages: [] };
-        const introductionState = {
-          name: '',
-          level: '',
-          goal: '',
-          timestamp: '',
-        };
-        const templateData = {
-          messages: conversationState.messages || [],
-          current_input: currentInput,
-          introduction_state: introductionState,
-        };
-
-        const renderedPrompt = await renderJinja(
-          conversationTemplate,
-          JSON.stringify(templateData)
-        );
-
-        return new GraphTypes.LLMChatRequest({
-          messages: [{ role: 'user', content: renderedPrompt }],
-        });
-      }
-
-      // Get state directly from accessors
-      const conversationState = stateAccessors.getConversationState();
-      const introductionState = stateAccessors.getIntroductionState();
-
-      const templateData = {
-        messages: conversationState.messages || [],
-        current_input: currentInput,
-        introduction_state: introductionState || {
-          name: '',
-          level: '',
-          goal: '',
-        },
-      };
-
-      console.log(
-        'ConversationGraph - Introduction state being used:',
-        JSON.stringify(introductionState, null, 2)
-      );
-      console.log(
-        'ConversationGraph - Number of messages in history:',
-        conversationState.messages?.length || 0
-      );
-
-      const renderedPrompt = await renderJinja(
-        conversationTemplate,
-        JSON.stringify(templateData)
-      );
-
-      // Return LLMChatRequest for the LLM node
-      return new GraphTypes.LLMChatRequest({
-        messages: [{ role: 'user', content: renderedPrompt }],
-      });
-    }
+// Store the current execution context as module-level variables
+// This is set by AudioProcessor before starting graph execution
+// and read by the PromptBuilder during execution.
+// This works because Node.js is single-threaded for synchronous execution.
+let currentExecutionLanguageCode: string = DEFAULT_LANGUAGE_CODE;
+let currentGetConversationState: (() => { messages: Array<{ role: string; content: string; timestamp: string }> }) | null = null;
+let currentGetIntroductionState: (() => IntroductionState) | null = null;
+
+/**
+ * Set the execution context for the current graph execution.
+ * Must be called before starting graph execution.
+ */
+export function setCurrentExecutionContext(context: {
+  languageCode: string;
+  getConversationState: () => { messages: Array<{ role: string; content: string; timestamp: string }> };
+  getIntroductionState: () => IntroductionState;
+}): void {
+  currentExecutionLanguageCode = context.languageCode;
+  currentGetConversationState = context.getConversationState;
+  currentGetIntroductionState = context.getIntroductionState;
+  console.log(`[ConversationGraph] Set execution context for language: ${context.languageCode}`);
+}
+
+/**
+ * Set the language code for the current graph execution.
+ * @deprecated Use setCurrentExecutionContext instead
+ */
+export function setCurrentExecutionLanguage(languageCode: string): void {
+  currentExecutionLanguageCode = languageCode;
+  console.log(`[ConversationGraph] Set execution language to: ${languageCode}`);
+}
+
+/**
+ * EnhancedPromptBuilderNode - defined once at module level to avoid
+ * component registry collisions. State and language config are retrieved from
+ * module-level variables (set by AudioProcessor before graph execution).
+ */
+class EnhancedPromptBuilderNode extends CustomNode {
+  async process(_context: ProcessContext, currentInput: string) {
+    // Get language config using the current execution language code
+    const langConfig = getLanguageConfig(currentExecutionLanguageCode);
+    const nodeId = (this as unknown as { id: string }).id;
+
+    console.log(
+      `[PromptBuilder] Node ${nodeId} using execution language: ${langConfig.name} (code: ${currentExecutionLanguageCode})`
+    );
+
+    // Build template variables from language config
+    const templateVars = {
+      target_language: langConfig.name,
+      target_language_native: langConfig.nativeName,
+      teacher_name: langConfig.teacherPersona.name,
+      teacher_description: langConfig.teacherPersona.description,
+      example_topics: langConfig.exampleTopics.join(', '),
+      language_instructions: langConfig.promptInstructions,
+    };
+
+    // Get state from module-level accessors (set by AudioProcessor before execution)
+    // These bypass AsyncLocalStorage which gets broken by Inworld runtime
+    const conversationState = currentGetConversationState
+      ? currentGetConversationState()
+      : { messages: [] };
+    const introductionState = currentGetIntroductionState
+      ? currentGetIntroductionState()
+      : { name: '', level: '', goal: '', timestamp: '' };
+
+    console.log(
+      '[PromptBuilder] Introduction state:',
+      JSON.stringify(introductionState, null, 2)
+    );
+    console.log('[PromptBuilder] Language:', langConfig.name);
+    console.log(
+      '[PromptBuilder] Messages in history:',
+      conversationState.messages?.length || 0
+    );
+
+    const templateData = {
+      messages: conversationState.messages || [],
+      current_input: currentInput,
+      introduction_state: introductionState,
+      ...templateVars,
+    };
+
+    const renderedPrompt = await renderJinja(
+      conversationTemplate,
+      JSON.stringify(templateData)
+    );
+
+    // Debug: Log a snippet of the rendered prompt to verify content
+    const promptSnippet = renderedPrompt.substring(0, 400);
+    console.log(
+      `[PromptBuilder] Rendered prompt (first 400 chars): ${promptSnippet}...`
+    );
+
+    // Return LLMChatRequest for the LLM node
+    return new GraphTypes.LLMChatRequest({
+      messages: [{ role: 'user', content: renderedPrompt }],
+    });
   }
+}
+
+/**
+ * Creates a conversation graph configured for a specific language
+ */
+function createConversationGraphForLanguage(
+  _config: ConversationGraphConfig,
+  languageConfig: LanguageConfig
+): Graph {
 
+  // Use language code as suffix to make node IDs unique per language
+  // This prevents edge condition name collisions in the global callback registry
+  const langSuffix = `_${languageConfig.code}`;
+  const promptBuilderNodeId = `enhanced_prompt_builder_node${langSuffix}`;
+
+  console.log(
+    `[ConversationGraph] Creating graph with prompt builder node: ${promptBuilderNodeId}`
+  );
+
+  // Configure STT for the specific language
   const sttNode = new RemoteSTTNode({
-    id: 'stt_node',
+    id: `stt_node${langSuffix}`,
     sttConfig: {
-      languageCode: 'es',
+      languageCode: languageConfig.sttLanguageCode,
     },
   });
+
   const sttOutputNode = new ProxyNode({
-    id: 'proxy_node',
+    id: `proxy_node${langSuffix}`,
     reportToClient: true,
   });
+
   const promptBuilderNode = new EnhancedPromptBuilderNode({
-    id: 'enhanced_prompt_builder_node',
+    id: promptBuilderNodeId,
   });
+
   const llmNode = new RemoteLLMChatNode({
-    id: 'llm_node',
+    id: `llm_node${langSuffix}`,
     provider: 'openai',
     modelName: 'gpt-4o-mini',
     stream: true,
@@ -123,18 +185,22 @@ export function createConversationGraph(_config: ConversationGraphConfig) {
       presencePenalty: 0,
     },
   });
-  const chunkerNode = new TextChunkingNode({ id: 'chunker_node' });
+
+  const chunkerNode = new TextChunkingNode({ id: `chunker_node${langSuffix}` });
+
+  // Configure TTS for the specific language
   const ttsNode = new RemoteTTSNode({
-    id: 'tts_node',
-    speakerId: 'Diego',
-    modelId: 'inworld-tts-1',
+    id: `tts_node${langSuffix}`,
+    speakerId: languageConfig.ttsConfig.speakerId,
+    modelId: languageConfig.ttsConfig.modelId,
     sampleRate: 16000,
-    speakingRate: 1,
-    temperature: 0.7,
+    speakingRate: languageConfig.ttsConfig.speakingRate,
+    temperature: languageConfig.ttsConfig.temperature,
+    languageCode: languageConfig.ttsConfig.languageCode,
   });
 
   const executor = new GraphBuilder({
-    id: 'conversation_graph',
+    id: `conversation_graph_${languageConfig.code}`,
     enableRemoteConfig: false,
   })
     .addNode(sttNode)
@@ -159,3 +225,43 @@ export function createConversationGraph(_config: ConversationGraphConfig) {
 
   return executor;
 }
+
+// Cache for language-specific graphs
+const graphCache = new Map<string, Graph>();
+
+/**
+ * Get or create a conversation graph for a specific language
+ * Graphs are cached to avoid recreation overhead
+ */
+export function getConversationGraph(
+  config: ConversationGraphConfig,
+  languageCode: string = DEFAULT_LANGUAGE_CODE
+): Graph {
+  const cacheKey = languageCode;
+
+  if (!graphCache.has(cacheKey)) {
+    const languageConfig = getLanguageConfig(languageCode);
+    console.log(
+      `Creating conversation graph for language: ${languageConfig.name} (${languageCode})`
+    );
+    const graph = createConversationGraphForLanguage(config, languageConfig);
+    graphCache.set(cacheKey, graph);
+  }
+
+  return graphCache.get(cacheKey)!;
+}
+
+/**
+ * Legacy function for backwards compatibility
+ * Creates or returns the default (Spanish) graph
+ */
+export function createConversationGraph(config: ConversationGraphConfig): Graph {
+  return getConversationGraph(config, DEFAULT_LANGUAGE_CODE);
+}
+
+/**
+ * Clear the graph cache (useful for testing or reconfiguration)
+ */
+export function clearGraphCache(): void {
+  graphCache.clear();
+}
diff --git a/backend/graphs/flashcard-graph.ts b/backend/graphs/flashcard-graph.ts
index 8452137..3990d7e 100644
--- a/backend/graphs/flashcard-graph.ts
+++ b/backend/graphs/flashcard-graph.ts
@@ -6,12 +6,18 @@ import {
   CustomNode,
   ProcessContext,
   RemoteLLMChatNode,
+  Graph,
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
 import { renderJinja } from '@inworld/runtime/primitives/llm';
 import { flashcardPromptTemplate } from '../helpers/prompt-templates.js';
 import { v4 } from 'uuid';
 import { Flashcard } from '../helpers/flashcard-processor.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 class FlashcardPromptBuilderNode extends CustomNode {
   async process(
@@ -51,7 +57,8 @@ class FlashcardParserNode extends CustomNode {
         const parsed = JSON.parse(jsonMatch[0]);
         return {
           id: v4(),
-          spanish: parsed.spanish ?? '',
+          // Support both new 'targetWord' format and legacy 'spanish' format
+          targetWord: parsed.targetWord ?? parsed.spanish ?? '',
           english: parsed.english ?? '',
           example: parsed.example ?? '',
           mnemonic: parsed.mnemonic ?? '',
@@ -64,7 +71,7 @@ class FlashcardParserNode extends CustomNode {
 
     return {
       id: v4(),
-      spanish: '',
+      targetWord: '',
       english: '',
       example: '',
       mnemonic: '',
@@ -74,7 +81,10 @@ class FlashcardParserNode extends CustomNode {
   }
 }
 
-export function createFlashcardGraph() {
+/**
+ * Creates a flashcard generation graph for a specific language
+ */
+function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph {
   const apiKey = process.env.INWORLD_API_KEY;
   if (!apiKey) {
     throw new Error('INWORLD_API_KEY environment variable is required');
@@ -104,7 +114,7 @@ export function createFlashcardGraph() {
   const parserNode = new FlashcardParserNode({ id: 'flashcard-parser' });
 
   const executor = new GraphBuilder({
-    id: 'flashcard-generation-graph',
+    id: `flashcard-generation-graph-${languageConfig.code}`,
     enableRemoteConfig: true,
   })
     .addNode(promptBuilderNode)
@@ -118,7 +128,38 @@ export function createFlashcardGraph() {
     .setEndNode(parserNode)
     .build();
 
-  fs.writeFileSync('flashcard-graph.json', executor.toJSON());
+  // Only write debug file for default language to avoid cluttering
+  if (languageConfig.code === DEFAULT_LANGUAGE_CODE) {
+    fs.writeFileSync('flashcard-graph.json', executor.toJSON());
+  }
 
   return executor;
 }
+
+// Cache for language-specific flashcard graphs
+const flashcardGraphCache = new Map<string, Graph>();
+
+/**
+ * Get or create a flashcard graph for a specific language
+ */
+export function getFlashcardGraph(
+  languageCode: string = DEFAULT_LANGUAGE_CODE
+): Graph {
+  if (!flashcardGraphCache.has(languageCode)) {
+    const languageConfig = getLanguageConfig(languageCode);
+    console.log(
+      `Creating flashcard graph for language: ${languageConfig.name} (${languageCode})`
+    );
+    const graph = createFlashcardGraphForLanguage(languageConfig);
+    flashcardGraphCache.set(languageCode, graph);
+  }
+
+  return flashcardGraphCache.get(languageCode)!;
+}
+
+/**
+ * Legacy function for backwards compatibility
+ */
+export function createFlashcardGraph(): Graph {
+  return getFlashcardGraph(DEFAULT_LANGUAGE_CODE);
+}
diff --git a/backend/graphs/introduction-state-graph.ts b/backend/graphs/introduction-state-graph.ts
index ae078a9..fb929a9 100644
--- a/backend/graphs/introduction-state-graph.ts
+++ b/backend/graphs/introduction-state-graph.ts
@@ -4,10 +4,16 @@ import {
   CustomNode,
   ProcessContext,
   RemoteLLMChatNode,
+  Graph,
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
 import { renderJinja } from '@inworld/runtime/primitives/llm';
 import { introductionStatePromptTemplate } from '../helpers/prompt-templates.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 type IntroductionStateLevel = 'beginner' | 'intermediate' | 'advanced' | '';
 
@@ -39,20 +45,53 @@ class TextToChatRequestNode extends CustomNode {
   }
 }
 
+/**
+ * Normalize level strings from various languages to standard values
+ * Supports: English, Spanish, Japanese, French (and more can be added)
+ */
 function normalizeLevel(level: unknown): IntroductionStateLevel {
   if (typeof level !== 'string') return '';
   const lower = level
     .trim()
     .toLowerCase()
     .replace(/[.!?,;:]+$/g, '');
+
   const mapping: Record<string, IntroductionStateLevel> = {
+    // English
     beginner: 'beginner',
     intermediate: 'intermediate',
     advanced: 'advanced',
+    // Spanish
     principiante: 'beginner',
     intermedio: 'intermediate',
     avanzado: 'advanced',
+    // French
+    débutant: 'beginner',
+    debutant: 'beginner',
+    intermédiaire: 'intermediate',
+    intermediaire: 'intermediate',
+    avancé: 'advanced',
+    avance: 'advanced',
+    // Japanese (romanji)
+    shoshinsha: 'beginner',
+    chūkyū: 'intermediate',
+    chuukyuu: 'intermediate',
+    jōkyū: 'advanced',
+    joukyuu: 'advanced',
+    // Japanese (hiragana/katakana - common responses)
+    初心者: 'beginner',
+    中級: 'intermediate',
+    上級: 'advanced',
+    // Additional variations
+    basic: 'beginner',
+    elementary: 'beginner',
+    beginning: 'beginner',
+    middle: 'intermediate',
+    medium: 'intermediate',
+    expert: 'advanced',
+    fluent: 'advanced',
   };
+
   return mapping[lower] || '';
 }
 
@@ -104,7 +143,12 @@ class IntroductionStateParserNode extends CustomNode {
   }
 }
 
-export function createIntroductionStateGraph() {
+/**
+ * Create an introduction state extraction graph for a specific language
+ */
+function createIntroductionStateGraphForLanguage(
+  languageConfig: LanguageConfig
+): Graph {
   const apiKey = process.env.INWORLD_API_KEY;
   if (!apiKey) {
     throw new Error('INWORLD_API_KEY environment variable is required');
@@ -126,7 +170,9 @@ export function createIntroductionStateGraph() {
     id: 'introduction-state-parser',
   });
 
-  const executor = new GraphBuilder('introduction-state-graph')
+  const executor = new GraphBuilder({
+    id: `introduction-state-graph-${languageConfig.code}`,
+  })
     .addNode(promptBuilderNode)
     .addNode(textToChatRequestNode)
     .addNode(llmNode)
@@ -140,3 +186,31 @@ export function createIntroductionStateGraph() {
 
   return executor;
 }
+
+// Cache for language-specific introduction state graphs
+const introductionStateGraphCache = new Map<string, Graph>();
+
+/**
+ * Get or create an introduction state graph for a specific language
+ */
+export function getIntroductionStateGraph(
+  languageCode: string = DEFAULT_LANGUAGE_CODE
+): Graph {
+  if (!introductionStateGraphCache.has(languageCode)) {
+    const languageConfig = getLanguageConfig(languageCode);
+    console.log(
+      `Creating introduction state graph for language: ${languageConfig.name} (${languageCode})`
+    );
+    const graph = createIntroductionStateGraphForLanguage(languageConfig);
+    introductionStateGraphCache.set(languageCode, graph);
+  }
+
+  return introductionStateGraphCache.get(languageCode)!;
+}
+
+/**
+ * Legacy function for backwards compatibility
+ */
+export function createIntroductionStateGraph(): Graph {
+  return getIntroductionStateGraph(DEFAULT_LANGUAGE_CODE);
+}
diff --git a/backend/helpers/anki-exporter.ts b/backend/helpers/anki-exporter.ts
index bc78c88..16f47ba 100644
--- a/backend/helpers/anki-exporter.ts
+++ b/backend/helpers/anki-exporter.ts
@@ -8,28 +8,37 @@ export class AnkiExporter {
    */
   async exportFlashcards(
     flashcards: Flashcard[],
-    deckName: string = 'Aprendemo Spanish Cards'
+    deckName: string = 'Aprendemo Language Cards'
   ): Promise<Buffer> {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const apkg = new (AnkiExport as any).default(deckName);
 
     // Add each flashcard as a card
     flashcards.forEach((flashcard) => {
+      // Support both new 'targetWord' and legacy 'spanish' field
+      const targetWord = flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
+
       // Skip empty or error flashcards
       if (
-        !flashcard.spanish ||
+        !targetWord ||
         !flashcard.english ||
-        flashcard.spanish.trim() === '' ||
+        targetWord.trim() === '' ||
         flashcard.english.trim() === ''
       ) {
         return;
       }
 
-      const front = flashcard.spanish.trim();
+      const front = targetWord.trim();
       const back = this.formatCardBack(flashcard);
 
       // Add tags for organization
-      const tags = ['aprendemo', 'spanish-learning'];
+      const tags = ['aprendemo'];
+
+      // Add language tag if available
+      if (flashcard.languageCode) {
+        tags.push(`language-${flashcard.languageCode}`);
+      }
+
       if (flashcard.timestamp) {
         const date = new Date(flashcard.timestamp).toISOString().split('T')[0];
         tags.push(`created-${date}`);
@@ -76,12 +85,14 @@ export class AnkiExporter {
    * Count valid flashcards (ones that can be exported)
    */
   countValidFlashcards(flashcards: Flashcard[]): number {
-    return flashcards.filter(
-      (flashcard) =>
-        flashcard.spanish &&
+    return flashcards.filter((flashcard) => {
+      const targetWord = flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
+      return (
+        targetWord &&
         flashcard.english &&
-        flashcard.spanish.trim() !== '' &&
+        targetWord.trim() !== '' &&
         flashcard.english.trim() !== ''
-    ).length;
+      );
+    }).length;
   }
 }
diff --git a/backend/helpers/audio-processor.ts b/backend/helpers/audio-processor.ts
index 59e2c51..1a122c7 100644
--- a/backend/helpers/audio-processor.ts
+++ b/backend/helpers/audio-processor.ts
@@ -4,8 +4,13 @@ import { UserContextInterface } from '@inworld/runtime/graph';
 import { Graph } from '@inworld/runtime/graph';
 import { WebSocket } from 'ws';
 import { SileroVAD, VADConfig } from './silero-vad.js';
-import { stateStorage } from '../graphs/conversation-graph.js';
+import { stateStorage, setCurrentExecutionContext } from '../graphs/conversation-graph.js';
 import type { IntroductionState } from './introduction-state-processor.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 export class AudioProcessor {
   private executor: Graph;
@@ -37,13 +42,57 @@ export class AudioProcessor {
   private targetingKey: string | null = null;
   private clientTimezone: string | null = null;
   private graphStartTime: number = 0;
-  constructor(executor: Graph, websocket?: WebSocket) {
+  private languageCode: string = DEFAULT_LANGUAGE_CODE;
+  private languageConfig: LanguageConfig;
+
+  constructor(
+    executor: Graph,
+    websocket?: WebSocket,
+    languageCode: string = DEFAULT_LANGUAGE_CODE
+  ) {
     this.executor = executor;
     this.websocket = websocket ?? null;
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
     this.setupWebSocketMessageHandler();
     setTimeout(() => this.initialize(), 100);
   }
 
+  /**
+   * Update the language and graph for this processor
+   */
+  setLanguage(languageCode: string, newGraph: Graph): void {
+    if (this.languageCode !== languageCode) {
+      console.log(
+        `AudioProcessor: Changing language from ${this.languageCode} to ${languageCode}`
+      );
+      this.languageCode = languageCode;
+      this.languageConfig = getLanguageConfig(languageCode);
+      this.executor = newGraph;
+
+      // Reset conversation state when language changes
+      this.reset();
+
+      console.log(
+        `AudioProcessor: Language changed to ${this.languageConfig.name}`
+      );
+    }
+  }
+
+  /**
+   * Get current language code
+   */
+  getLanguageCode(): string {
+    return this.languageCode;
+  }
+
+  /**
+   * Get current language config
+   */
+  getLanguageConfig(): LanguageConfig {
+    return this.languageConfig;
+  }
+
   // Public methods for state registry access
   getConversationState() {
     return this.conversationState;
@@ -254,7 +303,7 @@ export class AudioProcessor {
       // Just mark as ready
       this.isReady = true;
       console.log(
-        'AudioProcessor: Using shared conversation graph, ready for audio processing'
+        `AudioProcessor: Using ${this.languageConfig.name} conversation graph, ready for audio processing`
       );
     } catch (error) {
       console.error(
@@ -330,6 +379,7 @@ export class AudioProcessor {
       // Build user context for experiments
       const attributes: Record<string, string> = {
         timezone: this.clientTimezone || '',
+        language: this.languageCode,
       };
       attributes.name =
         (this.introductionState?.name && this.introductionState.name.trim()) ||
@@ -351,12 +401,21 @@ export class AudioProcessor {
 
       this.graphStartTime = Date.now();
 
-      // Use AsyncLocalStorage to set state accessors for this execution context
-      // This allows the graph nodes to access state directly without needing connectionId
+      // Set the current execution context BEFORE starting the graph
+      // This ensures the PromptBuilder node has access to state and language config
+      // We use module-level variables because Inworld runtime breaks AsyncLocalStorage context
+      setCurrentExecutionContext({
+        languageCode: this.languageCode,
+        getConversationState: () => this.getConversationState(),
+        getIntroductionState: () => this.getIntroductionState(),
+      });
+
+      // Also use AsyncLocalStorage as a fallback (may work in some contexts)
       const executionResult = await stateStorage.run(
         {
           getConversationState: () => this.getConversationState(),
           getIntroductionState: () => this.getIntroductionState(),
+          getLanguageConfig: () => this.getLanguageConfig(),
         },
         async () => {
           try {
@@ -400,7 +459,15 @@ export class AudioProcessor {
           string: (data: string) => {
             transcription = data;
 
+            // Debug: always log raw STT result for troubleshooting
+            console.log(
+              `VAD STT Raw Result [${this.languageCode}]: "${data}" (length: ${data.length}, trimmed: ${data.trim().length})`
+            );
+
             if (transcription.trim() === '') {
+              console.log(
+                `VAD STT: Empty transcription for ${this.languageCode}, skipping LLM`
+              );
               return;
             }
 
diff --git a/backend/helpers/flashcard-processor.ts b/backend/helpers/flashcard-processor.ts
index ab1b028..ef82b3c 100644
--- a/backend/helpers/flashcard-processor.ts
+++ b/backend/helpers/flashcard-processor.ts
@@ -2,15 +2,21 @@ import { v4 } from 'uuid';
 import { Graph } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
 import { UserContextInterface } from '@inworld/runtime/graph';
-import { createFlashcardGraph } from '../graphs/flashcard-graph.js';
+import { getFlashcardGraph } from '../graphs/flashcard-graph.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 export interface Flashcard {
   id: string;
-  spanish: string;
+  targetWord: string; // The word in the target language (was 'spanish')
   english: string;
   example: string;
   mnemonic: string;
   timestamp: string;
+  languageCode?: string; // Track which language this card belongs to
 }
 
 export interface ConversationMessage {
@@ -20,9 +26,30 @@ export interface ConversationMessage {
 
 export class FlashcardProcessor {
   private existingFlashcards: Flashcard[] = [];
+  private languageCode: string = DEFAULT_LANGUAGE_CODE;
+  private languageConfig: LanguageConfig;
 
-  constructor() {
-    // Initialize with empty flashcard array
+  constructor(languageCode: string = DEFAULT_LANGUAGE_CODE) {
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
+  }
+
+  /**
+   * Update the language for this processor
+   */
+  setLanguage(languageCode: string): void {
+    if (this.languageCode !== languageCode) {
+      this.languageCode = languageCode;
+      this.languageConfig = getLanguageConfig(languageCode);
+      console.log(`FlashcardProcessor: Language changed to ${this.languageConfig.name}`);
+    }
+  }
+
+  /**
+   * Get current language code
+   */
+  getLanguageCode(): string {
+    return this.languageCode;
   }
 
   async generateFlashcards(
@@ -30,7 +57,7 @@ export class FlashcardProcessor {
     count: number = 1,
     userContext?: UserContextInterface
   ): Promise<Flashcard[]> {
-    const executor = createFlashcardGraph();
+    const executor = getFlashcardGraph(this.languageCode);
 
     // Generate flashcards in parallel
     const promises: Promise<Flashcard>[] = [];
@@ -46,7 +73,7 @@ export class FlashcardProcessor {
 
       // Filter out any failed generations and duplicates
       const validFlashcards = flashcards.filter(
-        (card) => card.spanish && card.english
+        (card) => card.targetWord && card.english
       );
 
       // Add to existing flashcards to track for future duplicates
@@ -67,7 +94,8 @@ export class FlashcardProcessor {
     try {
       const input = {
         studentName: 'Student',
-        teacherName: 'Señor Rosales',
+        teacherName: this.languageConfig.teacherPersona.name,
+        target_language: this.languageConfig.name,
         messages: messages,
         flashcards: this.existingFlashcards,
       };
@@ -92,10 +120,13 @@ export class FlashcardProcessor {
       }
       const flashcard = finalData as unknown as Flashcard;
 
+      // Add language code to the flashcard
+      flashcard.languageCode = this.languageCode;
+
       // Check if this is a duplicate
       const isDuplicate = this.existingFlashcards.some(
         (existing) =>
-          existing.spanish?.toLowerCase() === flashcard.spanish?.toLowerCase()
+          existing.targetWord?.toLowerCase() === flashcard.targetWord?.toLowerCase()
       );
 
       if (isDuplicate) {
@@ -103,11 +134,12 @@ export class FlashcardProcessor {
         // For simplicity, we'll just return an empty flashcard if duplicate
         return {
           id: v4(),
-          spanish: '',
+          targetWord: '',
           english: '',
           example: '',
           mnemonic: '',
           timestamp: new Date().toISOString(),
+          languageCode: this.languageCode,
         } as Flashcard & { error?: string };
       }
 
@@ -116,11 +148,12 @@ export class FlashcardProcessor {
       console.error('Error generating single flashcard:', error);
       return {
         id: v4(),
-        spanish: '',
+        targetWord: '',
         english: '',
         example: '',
         mnemonic: '',
         timestamp: new Date().toISOString(),
+        languageCode: this.languageCode,
       } as Flashcard & { error?: string };
     }
   }
diff --git a/backend/helpers/introduction-state-processor.ts b/backend/helpers/introduction-state-processor.ts
index 678cfb3..ea465fe 100644
--- a/backend/helpers/introduction-state-processor.ts
+++ b/backend/helpers/introduction-state-processor.ts
@@ -1,7 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Graph } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
-import { createIntroductionStateGraph } from '../graphs/introduction-state-graph.js';
+import { getIntroductionStateGraph } from '../graphs/introduction-state-graph.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
 
 export type IntroductionStateLevel =
   | 'beginner'
@@ -29,9 +34,34 @@ export class IntroductionStateProcessor {
     timestamp: '',
   };
   private executor: Graph;
+  private languageCode: string = DEFAULT_LANGUAGE_CODE;
+  private languageConfig: LanguageConfig;
 
-  constructor() {
-    this.executor = createIntroductionStateGraph();
+  constructor(languageCode: string = DEFAULT_LANGUAGE_CODE) {
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
+    this.executor = getIntroductionStateGraph(languageCode);
+  }
+
+  /**
+   * Update the language for this processor
+   */
+  setLanguage(languageCode: string): void {
+    if (this.languageCode !== languageCode) {
+      this.languageCode = languageCode;
+      this.languageConfig = getLanguageConfig(languageCode);
+      this.executor = getIntroductionStateGraph(languageCode);
+      console.log(
+        `IntroductionStateProcessor: Language changed to ${this.languageConfig.name}`
+      );
+    }
+  }
+
+  /**
+   * Get current language code
+   */
+  getLanguageCode(): string {
+    return this.languageCode;
   }
 
   isComplete(): boolean {
@@ -68,6 +98,7 @@ export class IntroductionStateProcessor {
       const input = {
         messages,
         existingState: this.state,
+        target_language: this.languageConfig.name,
       };
 
       console.log(
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index 4a2c64d..b07e1ef 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -1,39 +1,51 @@
+/**
+ * Prompt Templates for Multi-Language Support
+ *
+ * All templates use Jinja2-style variables that are injected at runtime:
+ * - {{target_language}} - English name of target language (e.g., "Spanish")
+ * - {{target_language_native}} - Native name (e.g., "Español")
+ * - {{teacher_name}} - Teacher persona name
+ * - {{teacher_description}} - Full teacher persona description
+ * - {{example_topics}} - Comma-separated list of conversation topics
+ * - {{language_instructions}} - Language-specific teaching instructions
+ */
+
 export const conversationTemplate = `
 
 # Context
-- You are a Señor Gael Herrera, 35 year old 'Chilango' who has loaned their brain to AI.
-- You are embedded in a Spanish learning app called 'Aprendemo', which is a demonstration of the Inworld AI Runtime.
-- You can help the user learn Spanish by having natural (verbalized) conversations with them.
+- You are {{teacher_name}}, {{teacher_description}}.
+- You are embedded in a {{target_language}} learning app called 'Aprendemo', which is a demonstration of the Inworld AI Runtime.
+- You can help the user learn {{target_language}} by having natural (verbalized) conversations with them.
 - The app generates flashcards for the user during the conversation. They are ANKI formatted and can be exported by the user.
 
 # Instructions
 {% if introduction_state and (not introduction_state.name or not introduction_state.level or not introduction_state.goal) %}
-- Your first priority is to collect missing onboarding info. Ask for exactly one missing item at a time, in Spanish, and keep it short and natural.
+- Your first priority is to collect missing onboarding info. Ask for exactly one missing item at a time, in {{target_language}}, and keep it short and natural.
 - Missing items to collect:
   {% if not introduction_state.name %}- Ask their name.
   {% endif %}
-  {% if not introduction_state.level %}- Ask their Spanish level (beginner, intermediate, or advanced).
+  {% if not introduction_state.level %}- Ask their {{target_language}} level (beginner, intermediate, or advanced).
   {% endif %}
-  {% if not introduction_state.goal %}- Ask their goal for learning Spanish.
+  {% if not introduction_state.goal %}- Ask their goal for learning {{target_language}}.
   {% endif %}
 - Do not assume or guess values. If a value was already collected, do not ask for it again.
-- If the user's latest message appears to answer one of these (e.g., they state their name, level like "principiante/intermedio/avanzado" or "beginner/intermediate/advanced", or share a goal), acknowledge it and immediately move to the next missing item instead of repeating the same question.
+- If the user's latest message appears to answer one of these (e.g., they state their name, level like "beginner/intermediate/advanced" or equivalent in {{target_language}}, or share a goal), acknowledge it and immediately move to the next missing item instead of repeating the same question.
 - Use the name naturally as soon as they provide it.
 {% else %}
-- Greet the user and introduce yourself in Spanish
+- Greet the user and introduce yourself in {{target_language}}
 - Ask the user if they want a lesson or conversation on a specific topic, then proceed
-- If they don't want anything in particular, lead them in a conversation or lesson about Mexico City, the Dunedin sound rock scene, gardening, the concept of brunch across cultures, Balkan travel, or any other topic which comes to mind
+- If they don't want anything in particular, lead them in a conversation or lesson about {{example_topics}}, or any other topic which comes to mind
 - You can advise the user that if they want specific flashcards, they should just ask
-- Gently correct the user if they make mistakes
+{{language_instructions}}
 - Don't always ask the user questions, you can talk about yourself as well. Be natural!
 {% endif %}
 
 # Communication Style
-- Vary your conversation starters - don't always begin with "¡Hola!" or exclamations
+- Vary your conversation starters - don't always begin with greetings or exclamations
 - Respond naturally as if you're in the middle of an ongoing conversation
 - Use varied sentence structures and beginnings
-- Sometimes start with: direct responses, "Ah", "Bueno", "Claro", "Pues", "Sí", or simply dive into your response
-- Only use "¡Hola!" when it's actually a greeting at the start of a new conversation
+- Sometimes start with: direct responses, interjections, or simply dive into your response
+- Only use greetings when it's actually the start of a new conversation
 - Be conversational and natural, not overly enthusiastic with every response
 - When available, naturally use the user's name. Adjust complexity to their level (beginner, intermediate, advanced) and align topics with their goal.
 
@@ -50,13 +62,13 @@ Please respond naturally and clearly in 1-2 sentences. Vary your response style
 
 export const flashcardPromptTemplate = `
 
-You are a system that generates flashcards for interesting new vocabulary for a Spanish learning app.
+You are a system that generates flashcards for interesting new vocabulary for a {{target_language}} learning app.
 
 Based on the ongoing conversation between {{studentName}} and {{teacherName}}, generate one flashcard with the following things:
 
-- The word in Spanish
+- The word in {{target_language}}
 - The translation in English
-- An example sentence in Spanish
+- An example sentence in {{target_language}}
 - A mnemonic to help the student remember the word
 
 ## Conversation
@@ -67,7 +79,7 @@ Based on the ongoing conversation between {{studentName}} and {{teacherName}}, g
 ## Already Created Flashcards
 
 {% for flashcard in flashcards %}
-- Word: {{flashcard.spanish}}
+- Word: {{flashcard.targetWord}}
 {% endfor %}
 
 ## Guidelines
@@ -80,7 +92,7 @@ Based on the ongoing conversation between {{studentName}} and {{teacherName}}, g
 Now, return JSON with the following format:
 
 {
-  "spanish": "string",
+  "targetWord": "string",
   "english": "string",
   "example": "string",
   "mnemonic": "string"
@@ -88,7 +100,7 @@ Now, return JSON with the following format:
 
 export const introductionStatePromptTemplate = `
 
-You extract onboarding information for a Spanish learning app.
+You extract onboarding information for a {{target_language}} learning app.
 
 Your job is to collect the learner's name, level, and goal ONLY if they have been explicitly provided. Do not guess or infer.
 
diff --git a/backend/server.ts b/backend/server.ts
index 30b441f..23af9a7 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -21,7 +21,12 @@ import { AudioProcessor } from './helpers/audio-processor.js';
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
 import { AnkiExporter } from './helpers/anki-exporter.js';
 import { IntroductionStateProcessor } from './helpers/introduction-state-processor.js';
-import { createConversationGraph } from './graphs/conversation-graph.js';
+import { getConversationGraph } from './graphs/conversation-graph.js';
+import {
+  getLanguageConfig,
+  getLanguageOptions,
+  DEFAULT_LANGUAGE_CODE,
+} from './config/languages.js';
 
 const app = express();
 const server = createServer(app);
@@ -57,11 +62,6 @@ try {
   console.error('[Telemetry] Initialization failed:', err);
 }
 
-// Create a single shared conversation graph instance
-// State is passed directly through AsyncLocalStorage, no registry needed
-let sharedConversationGraph: ReturnType<typeof createConversationGraph> | null =
-  null;
-
 // Store audio processors per connection
 const audioProcessors = new Map<string, AudioProcessor>();
 const flashcardProcessors = new Map<string, FlashcardProcessor>();
@@ -69,20 +69,18 @@ const introductionStateProcessors = new Map<
   string,
   IntroductionStateProcessor
 >();
-// Store lightweight per-connection attributes provided by the client (e.g., timezone, userId)
+// Store lightweight per-connection attributes provided by the client (e.g., timezone, userId, languageCode)
 const connectionAttributes = new Map<
   string,
-  { timezone?: string; userId?: string }
+  { timezone?: string; userId?: string; languageCode?: string }
 >();
 
-// Initialize shared graph once at startup
-function initializeSharedGraph() {
-  if (!sharedConversationGraph) {
-    const apiKey = process.env.INWORLD_API_KEY || '';
-    sharedConversationGraph = createConversationGraph({ apiKey });
-    console.log('Shared conversation graph initialized');
-  }
-  return sharedConversationGraph;
+/**
+ * Get or create a conversation graph for the specified language
+ */
+function getGraphForLanguage(languageCode: string) {
+  const apiKey = process.env.INWORLD_API_KEY || '';
+  return getConversationGraph({ apiKey }, languageCode);
 }
 
 // WebSocket handling with audio processing
@@ -90,17 +88,22 @@ wss.on('connection', (ws) => {
   const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   console.log(`WebSocket connection established: ${connectionId}`);
 
-  // Create audio processor for this connection
-  // Use the shared graph instance - state is passed via AsyncLocalStorage
-  const sharedGraph = initializeSharedGraph();
-  const audioProcessor = new AudioProcessor(sharedGraph, ws);
-  const flashcardProcessor = new FlashcardProcessor();
-  const introductionStateProcessor = new IntroductionStateProcessor();
+  // Default language is Spanish
+  const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
+
+  // Create processors with default language
+  const graph = getGraphForLanguage(defaultLanguageCode);
+  const audioProcessor = new AudioProcessor(graph, ws, defaultLanguageCode);
+  const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
+  const introductionStateProcessor = new IntroductionStateProcessor(
+    defaultLanguageCode
+  );
 
-  // Register audio processor
+  // Register processors
   audioProcessors.set(connectionId, audioProcessor);
   flashcardProcessors.set(connectionId, flashcardProcessor);
   introductionStateProcessors.set(connectionId, introductionStateProcessor);
+  connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
 
   // Set up flashcard generation callback
   audioProcessor.setFlashcardCallback(async (messages) => {
@@ -215,6 +218,53 @@ wss.on('connection', (ws) => {
         }
 
         console.log(`Conversation restarted for connection: ${connectionId}`);
+      } else if (message.type === 'set_language') {
+        // Handle language change
+        const newLanguageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
+        const attrs = connectionAttributes.get(connectionId) || {};
+
+        // Only process if language actually changed
+        if (attrs.languageCode !== newLanguageCode) {
+          console.log(
+            `Language change requested for ${connectionId}: ${attrs.languageCode} -> ${newLanguageCode}`
+          );
+
+          // Update stored language
+          attrs.languageCode = newLanguageCode;
+          connectionAttributes.set(connectionId, attrs);
+
+          // Get the new language config
+          const languageConfig = getLanguageConfig(newLanguageCode);
+
+          // Update all processors with new language
+          const audioProc = audioProcessors.get(connectionId);
+          const flashcardProc = flashcardProcessors.get(connectionId);
+          const introStateProc = introductionStateProcessors.get(connectionId);
+
+          if (flashcardProc) {
+            flashcardProc.setLanguage(newLanguageCode);
+          }
+          if (introStateProc) {
+            introStateProc.setLanguage(newLanguageCode);
+          }
+          if (audioProc) {
+            // Audio processor needs a new graph for the new language
+            const newGraph = getGraphForLanguage(newLanguageCode);
+            audioProc.setLanguage(newLanguageCode, newGraph);
+          }
+
+          // Send confirmation to frontend
+          ws.send(
+            JSON.stringify({
+              type: 'language_changed',
+              languageCode: newLanguageCode,
+              languageName: languageConfig.name,
+              teacherName: languageConfig.teacherPersona.name,
+            })
+          );
+
+          console.log(`Language changed to ${languageConfig.name} for ${connectionId}`);
+        }
       } else if (message.type === 'user_context') {
         const timezone =
           message.timezone ||
@@ -222,7 +272,17 @@ wss.on('connection', (ws) => {
           undefined;
         const userId =
           message.userId || (message.data && message.data.userId) || undefined;
-        connectionAttributes.set(connectionId, { timezone, userId });
+        const languageCode =
+          message.languageCode ||
+          (message.data && message.data.languageCode) ||
+          undefined;
+        const currentAttrs = connectionAttributes.get(connectionId) || {};
+        connectionAttributes.set(connectionId, {
+          ...currentAttrs,
+          timezone: timezone || currentAttrs.timezone,
+          userId: userId || currentAttrs.userId,
+          languageCode: languageCode || currentAttrs.languageCode,
+        });
       } else if (message.type === 'flashcard_clicked') {
         try {
           const card = message.card || {};
@@ -233,10 +293,11 @@ wss.on('connection', (ws) => {
           telemetry.metric.recordCounterUInt('flashcard_clicks_total', 1, {
             connectionId,
             cardId: card.id || '',
-            spanish: card.spanish || card.word || '',
+            targetWord: card.targetWord || card.spanish || card.word || '',
             english: card.english || card.translation || '',
             source: 'ui',
             timezone: attrs.timezone || '',
+            languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
             name: (introState?.name && introState.name.trim()) || 'unknown',
             level:
               (introState?.level && (introState.level as string)) || 'unknown',
@@ -286,20 +347,25 @@ wss.on('connection', (ws) => {
 // API endpoint for ANKI export
 app.post('/api/export-anki', async (req, res) => {
   try {
-    const { flashcards, deckName } = req.body;
+    const { flashcards, deckName, languageCode } = req.body;
 
     if (!flashcards || !Array.isArray(flashcards)) {
       return res.status(400).json({ error: 'Invalid flashcards data' });
     }
 
+    // Get language config for deck naming
+    const langCode = languageCode || DEFAULT_LANGUAGE_CODE;
+    const languageConfig = getLanguageConfig(langCode);
+    const defaultDeckName = `Aprendemo ${languageConfig.name} Cards`;
+
     const exporter = new AnkiExporter();
     const ankiBuffer = await exporter.exportFlashcards(
       flashcards,
-      deckName || 'Aprendemo Spanish Cards'
+      deckName || defaultDeckName
     );
 
     // Set headers for file download
-    const filename = `${deckName || 'aprendemo_cards'}.apkg`;
+    const filename = `${deckName || `aprendemo_${langCode}_cards`}.apkg`;
     res.setHeader('Content-Type', 'application/octet-stream');
     res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
     res.setHeader('Content-Length', ankiBuffer.length);
@@ -314,6 +380,17 @@ app.post('/api/export-anki', async (req, res) => {
   }
 });
 
+// API endpoint to get supported languages
+app.get('/api/languages', (_req, res) => {
+  try {
+    const languages = getLanguageOptions();
+    res.json({ languages, defaultLanguage: DEFAULT_LANGUAGE_CODE });
+  } catch (error) {
+    console.error('Error getting languages:', error);
+    res.status(500).json({ error: 'Failed to get languages' });
+  }
+});
+
 // Serve static frontend files
 // When running from dist/backend/server.js, go up two levels to project root
 // When running from backend/server.ts (dev mode), go up one level to project root
diff --git a/flashcard-graph.json b/flashcard-graph.json
index 0f7f048..80be8e4 100644
--- a/flashcard-graph.json
+++ b/flashcard-graph.json
@@ -1,7 +1,7 @@
 {
   "schema_version": "1.2.0",
   "main": {
-    "id": "flashcard-generation-graph",
+    "id": "flashcard-generation-graph-es",
     "nodes": [
       {
         "type": "FlashcardPromptBuilderNodeType",
@@ -70,8 +70,12 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": ["flashcard-parser"],
-    "start_nodes": ["flashcard-prompt-builder"]
+    "end_nodes": [
+      "flashcard-parser"
+    ],
+    "start_nodes": [
+      "flashcard-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/frontend/index.html b/frontend/index.html
index e84a55b..7eb9aab 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -13,9 +13,16 @@
     <header class="header">
         <div class="container">
             <h1 class="logo">Aprendemo</h1>
-            <div class="status-indicator">
-                <span class="status-dot" id="statusDot"></span>
-                <span class="status-text" id="statusText">Connecting...</span>
+            <div class="header-controls">
+                <div class="language-selector">
+                    <select id="languageSelect" class="language-dropdown" disabled>
+                        <option value="es">🇲🇽 Spanish</option>
+                    </select>
+                </div>
+                <div class="status-indicator">
+                    <span class="status-dot" id="statusDot"></span>
+                    <span class="status-text" id="statusText">Connecting...</span>
+                </div>
             </div>
         </div>
     </header>
@@ -90,4 +97,4 @@ <h2>Flashcards</h2>
     
     <script type="module" src="js/main.js"></script>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/frontend/js/flashcard-ui.js b/frontend/js/flashcard-ui.js
index fa236a4..1d887da 100644
--- a/frontend/js/flashcard-ui.js
+++ b/frontend/js/flashcard-ui.js
@@ -3,10 +3,12 @@ export class FlashcardUI {
     this.flashcardsGrid = document.getElementById('flashcardsGrid');
     this.cardCount = document.getElementById('cardCount');
     this.flashcards = [];
+    this.currentLanguage = 'es';
   }
 
-  render(flashcards) {
+  render(flashcards, languageCode = 'es') {
     this.flashcards = flashcards;
+    this.currentLanguage = languageCode;
     this.updateCardCount(flashcards.length);
     this.renderFlashcards(flashcards);
   }
@@ -14,7 +16,7 @@ export class FlashcardUI {
   addFlashcards(newFlashcards) {
     // Add new flashcards to the existing collection
     this.flashcards = [...this.flashcards, ...newFlashcards];
-    this.render(this.flashcards);
+    this.render(this.flashcards, this.currentLanguage);
   }
 
   updateCardCount(count) {
@@ -65,10 +67,13 @@ export class FlashcardUI {
     const card = document.createElement('div');
     card.className = 'flashcard';
 
+    // Support both new 'targetWord' and legacy 'spanish' field
+    const targetWord = flashcard.targetWord || flashcard.spanish || flashcard.word || '';
+
     card.innerHTML = `
             <div class="flashcard-inner">
                 <div class="flashcard-front">
-                    <div class="flashcard-spanish">${this.escapeHtml(flashcard.spanish || flashcard.word || '')}</div>
+                    <div class="flashcard-target-word">${this.escapeHtml(targetWord)}</div>
                 </div>
                 <div class="flashcard-back">
                     <div class="flashcard-english">${this.escapeHtml(flashcard.english || flashcard.translation || '')}</div>
@@ -104,13 +109,15 @@ export class FlashcardUI {
   async exportToAnki() {
     try {
       // Filter out invalid flashcards
-      const validFlashcards = this.flashcards.filter(
-        (flashcard) =>
-          flashcard.spanish &&
+      const validFlashcards = this.flashcards.filter((flashcard) => {
+        const targetWord = flashcard.targetWord || flashcard.spanish;
+        return (
+          targetWord &&
           flashcard.english &&
-          flashcard.spanish.trim() !== '' &&
+          targetWord.trim() !== '' &&
           flashcard.english.trim() !== ''
-      );
+        );
+      });
 
       if (validFlashcards.length === 0) {
         alert('No valid flashcards to export');
@@ -122,6 +129,14 @@ export class FlashcardUI {
       this.cardCount.textContent = 'Exporting...';
       this.cardCount.style.cursor = 'wait';
 
+      // Get language name for deck naming
+      const languageNames = {
+        es: 'Spanish',
+        ja: 'Japanese',
+        fr: 'French',
+      };
+      const languageName = languageNames[this.currentLanguage] || 'Language';
+
       const response = await fetch('/api/export-anki', {
         method: 'POST',
         headers: {
@@ -129,7 +144,8 @@ export class FlashcardUI {
         },
         body: JSON.stringify({
           flashcards: validFlashcards,
-          deckName: 'Aprendemo Spanish Cards',
+          deckName: `Aprendemo ${languageName} Cards`,
+          languageCode: this.currentLanguage,
         }),
       });
 
@@ -142,7 +158,7 @@ export class FlashcardUI {
       const url = window.URL.createObjectURL(blob);
       const a = document.createElement('a');
       a.href = url;
-      a.download = 'aprendemo_cards.apkg';
+      a.download = `aprendemo_${this.currentLanguage}_cards.apkg`;
       document.body.appendChild(a);
       a.click();
       document.body.removeChild(a);
diff --git a/frontend/js/main.js b/frontend/js/main.js
index 0b60c4f..cf3f1d8 100644
--- a/frontend/js/main.js
+++ b/frontend/js/main.js
@@ -19,6 +19,10 @@ class App {
       this.wsClient.send({ type: 'flashcard_clicked', card });
     };
 
+    // Language state
+    this.currentLanguage = this.storage.getLanguage() || 'es';
+    this.availableLanguages = [];
+
     this.state = {
       chatHistory: [],
       flashcards: [],
@@ -41,11 +45,59 @@ class App {
   async init() {
     this.loadState();
     this.setupEventListeners();
+    await this.fetchLanguages();
     await this.connectWebSocket();
     await this.initializeAudioPlayer();
     this.render();
   }
 
+  async fetchLanguages() {
+    try {
+      const response = await fetch('/api/languages');
+      if (response.ok) {
+        const data = await response.json();
+        this.availableLanguages = data.languages;
+
+        // If current language is not in available languages, use default
+        const isValidLanguage = this.availableLanguages.some(
+          (lang) => lang.code === this.currentLanguage
+        );
+        if (!isValidLanguage) {
+          this.currentLanguage = data.defaultLanguage || 'es';
+        }
+
+        this.populateLanguageDropdown();
+      }
+    } catch (error) {
+      console.error('Failed to fetch languages:', error);
+      // Fallback to default language options
+      this.availableLanguages = [
+        { code: 'es', name: 'Spanish', nativeName: 'Español', flag: '🇲🇽' },
+        { code: 'ja', name: 'Japanese', nativeName: '日本語', flag: '🇯🇵' },
+        { code: 'fr', name: 'French', nativeName: 'Français', flag: '🇫🇷' },
+      ];
+      this.populateLanguageDropdown();
+    }
+  }
+
+  populateLanguageDropdown() {
+    const languageSelect = document.getElementById('languageSelect');
+    if (!languageSelect) return;
+
+    languageSelect.innerHTML = '';
+    this.availableLanguages.forEach((lang) => {
+      const option = document.createElement('option');
+      option.value = lang.code;
+      option.textContent = `${lang.flag} ${lang.name}`;
+      if (lang.code === this.currentLanguage) {
+        option.selected = true;
+      }
+      languageSelect.appendChild(option);
+    });
+
+    languageSelect.disabled = false;
+  }
+
   async initializeAudioPlayer() {
     try {
       await this.audioPlayer.initialize();
@@ -61,8 +113,8 @@ class App {
       this.state.chatHistory = savedState.chatHistory || [];
     }
 
-    // Load flashcards from storage
-    this.state.flashcards = this.storage.getFlashcards();
+    // Load flashcards from storage (for current language)
+    this.state.flashcards = this.storage.getFlashcards(this.currentLanguage);
 
     // Load existing conversation history
     const existingConversation = this.storage.getConversationHistory();
@@ -88,6 +140,7 @@ class App {
   setupEventListeners() {
     const micButton = document.getElementById('micButton');
     const restartButton = document.getElementById('restartButton');
+    const languageSelect = document.getElementById('languageSelect');
 
     // Check for iOS
     const isIOS =
@@ -143,11 +196,25 @@ class App {
       );
     }
 
+    // Language selector event listener
+    languageSelect.addEventListener('change', (e) => {
+      const newLanguage = e.target.value;
+      if (newLanguage !== this.currentLanguage) {
+        this.changeLanguage(newLanguage);
+      }
+    });
+
     this.wsClient.on('connection', (status) => {
       this.state.connectionStatus = status;
 
       // Send existing conversation history to backend when connected
       if (status === 'connected') {
+        // Send language preference first
+        this.wsClient.send({
+          type: 'set_language',
+          languageCode: this.currentLanguage,
+        });
+
         const existingConversation = this.storage.getConversationHistory();
         if (existingConversation.messages.length > 0) {
           console.log(
@@ -341,6 +408,12 @@ class App {
       this.handleInterrupt();
     });
 
+    // Handle language change confirmation from backend
+    this.wsClient.on('language_changed', (data) => {
+      console.log(`[Main] Language changed to ${data.languageName}`);
+      // Optionally show a notification or update UI
+    });
+
     this.audioHandler.on('audioChunk', (audioData) => {
       this.wsClient.sendAudioChunk(audioData);
     });
@@ -354,6 +427,57 @@ class App {
     });
   }
 
+  async changeLanguage(newLanguage) {
+    console.log(`[Main] Changing language from ${this.currentLanguage} to ${newLanguage}`);
+
+    // Stop any ongoing recording
+    if (this.state.isRecording) {
+      this.audioHandler.stopStreaming();
+      this.state.isRecording = false;
+    }
+
+    // Stop audio playback
+    try {
+      this.audioPlayer.stop();
+    } catch (error) {
+      console.error('Error stopping audio:', error);
+    }
+
+    // Update language
+    this.currentLanguage = newLanguage;
+    this.storage.saveLanguage(newLanguage);
+
+    // Clear conversation for new language
+    this.storage.clearConversation();
+    this.state.chatHistory = [];
+    this.state.currentTranscript = '';
+    this.state.currentLLMResponse = '';
+    this.state.pendingTranscription = null;
+    this.state.pendingLLMResponse = null;
+    this.state.streamingLLMResponse = '';
+    this.state.lastPendingTranscription = null;
+    this.state.speechDetected = false;
+    this.state.llmResponseComplete = false;
+    this.state.currentResponseId = null;
+
+    // Clear typewriters
+    this.chatUI.clearAllTypewriters();
+
+    // Load flashcards for new language
+    this.state.flashcards = this.storage.getFlashcards(newLanguage);
+
+    // Send language change to backend
+    if (this.wsClient && this.state.connectionStatus === 'connected') {
+      this.wsClient.send({
+        type: 'set_language',
+        languageCode: newLanguage,
+      });
+    }
+
+    // Re-render UI
+    this.render();
+  }
+
   async connectWebSocket() {
     try {
       await this.wsClient.connect();
@@ -364,6 +488,7 @@ class App {
           type: 'user_context',
           timezone: tz,
           userId: this.userId,
+          languageCode: this.currentLanguage,
         });
       } catch (e) {
         // ignore
@@ -596,14 +721,16 @@ class App {
   }
 
   addFlashcard(flashcard) {
-    const exists = this.state.flashcards.some(
-      (card) =>
-        card.spanish === flashcard.spanish || card.word === flashcard.word
-    );
+    // Use targetWord for deduplication (backwards compatible with spanish)
+    const targetWord = flashcard.targetWord || flashcard.spanish || flashcard.word;
+    const exists = this.state.flashcards.some((card) => {
+      const cardWord = card.targetWord || card.spanish || card.word;
+      return cardWord === targetWord;
+    });
 
     if (!exists) {
       this.state.flashcards.push(flashcard);
-      this.storage.addFlashcards([flashcard]);
+      this.storage.addFlashcards([flashcard], this.currentLanguage);
       this.saveState();
       this.render();
     }
@@ -611,7 +738,7 @@ class App {
 
   addMultipleFlashcards(flashcards) {
     // Use storage method which handles deduplication and persistence
-    const updatedFlashcards = this.storage.addFlashcards(flashcards);
+    const updatedFlashcards = this.storage.addFlashcards(flashcards, this.currentLanguage);
     this.state.flashcards = updatedFlashcards;
     this.saveState();
     this.render();
@@ -755,13 +882,16 @@ class App {
       this.state.isRecording,
       this.state.speechDetected
     );
-    this.flashcardUI.render(this.state.flashcards);
+    this.flashcardUI.render(this.state.flashcards, this.currentLanguage);
 
     const micButton = document.getElementById('micButton');
     const restartButton = document.getElementById('restartButton');
+    const languageSelect = document.getElementById('languageSelect');
+
     micButton.disabled = this.state.connectionStatus !== 'connected';
     micButton.classList.toggle('recording', this.state.isRecording);
     restartButton.disabled = this.state.connectionStatus !== 'connected';
+    languageSelect.disabled = this.state.connectionStatus !== 'connected';
   }
 
   updateConnectionStatus() {
diff --git a/frontend/js/storage.js b/frontend/js/storage.js
index 8ad4e7a..de011a8 100644
--- a/frontend/js/storage.js
+++ b/frontend/js/storage.js
@@ -3,6 +3,25 @@ export class Storage {
     this.storageKey = 'aprende-app-state';
     this.conversationKey = 'aprende-conversation-history';
     this.flashcardsKey = 'aprende-flashcards';
+    this.languageKey = 'aprende-language';
+  }
+
+  // Language preference methods
+  getLanguage() {
+    try {
+      return localStorage.getItem(this.languageKey) || 'es';
+    } catch (error) {
+      console.error('Failed to load language from localStorage:', error);
+      return 'es';
+    }
+  }
+
+  saveLanguage(languageCode) {
+    try {
+      localStorage.setItem(this.languageKey, languageCode);
+    } catch (error) {
+      console.error('Failed to save language to localStorage:', error);
+    }
   }
 
   saveState(state) {
@@ -94,11 +113,34 @@ export class Storage {
     }
   }
 
-  // Flashcard methods
-  getFlashcards() {
+  // Flashcard methods - now support per-language storage
+  _getFlashcardsKey(languageCode) {
+    if (!languageCode) {
+      return this.flashcardsKey;
+    }
+    return `${this.flashcardsKey}-${languageCode}`;
+  }
+
+  getFlashcards(languageCode) {
     try {
-      const serializedFlashcards = localStorage.getItem(this.flashcardsKey);
+      const key = this._getFlashcardsKey(languageCode);
+      const serializedFlashcards = localStorage.getItem(key);
       if (serializedFlashcards === null) {
+        // Try to migrate from old format if no language-specific data exists
+        if (languageCode === 'es') {
+          const oldFlashcards = localStorage.getItem(this.flashcardsKey);
+          if (oldFlashcards) {
+            const parsed = JSON.parse(oldFlashcards);
+            // Migrate old flashcards to new format
+            const migrated = parsed.map((card) => ({
+              ...card,
+              targetWord: card.targetWord || card.spanish || '',
+              languageCode: 'es',
+            }));
+            this.saveFlashcards(migrated, 'es');
+            return migrated;
+          }
+        }
         return [];
       }
       return JSON.parse(serializedFlashcards);
@@ -108,42 +150,67 @@ export class Storage {
     }
   }
 
-  saveFlashcards(flashcards) {
+  saveFlashcards(flashcards, languageCode) {
     try {
+      const key = this._getFlashcardsKey(languageCode);
       const serializedFlashcards = JSON.stringify(flashcards);
-      localStorage.setItem(this.flashcardsKey, serializedFlashcards);
+      localStorage.setItem(key, serializedFlashcards);
     } catch (error) {
       console.error('Failed to save flashcards to localStorage:', error);
     }
   }
 
-  addFlashcards(newFlashcards) {
-    const existingFlashcards = this.getFlashcards();
+  addFlashcards(newFlashcards, languageCode) {
+    const existingFlashcards = this.getFlashcards(languageCode);
 
-    // Filter out duplicates based on spanish word
+    // Filter out duplicates based on targetWord (backwards compatible with spanish)
     const uniqueNewFlashcards = newFlashcards.filter((newCard) => {
-      return !existingFlashcards.some(
-        (existing) =>
-          existing.spanish?.toLowerCase() === newCard.spanish?.toLowerCase()
-      );
+      const newWord = newCard.targetWord || newCard.spanish || '';
+      return !existingFlashcards.some((existing) => {
+        const existingWord = existing.targetWord || existing.spanish || '';
+        return existingWord.toLowerCase() === newWord.toLowerCase();
+      });
     });
 
-    const updatedFlashcards = [...existingFlashcards, ...uniqueNewFlashcards];
+    // Add language code to new flashcards
+    const flashcardsWithLanguage = uniqueNewFlashcards.map((card) => ({
+      ...card,
+      targetWord: card.targetWord || card.spanish || '',
+      languageCode: languageCode,
+    }));
 
-    // Keep only the last 100 flashcards
+    const updatedFlashcards = [...existingFlashcards, ...flashcardsWithLanguage];
+
+    // Keep only the last 100 flashcards per language
     if (updatedFlashcards.length > 100) {
       updatedFlashcards.splice(0, updatedFlashcards.length - 100);
     }
 
-    this.saveFlashcards(updatedFlashcards);
+    this.saveFlashcards(updatedFlashcards, languageCode);
     return updatedFlashcards;
   }
 
-  clearFlashcards() {
+  clearFlashcards(languageCode) {
     try {
-      localStorage.removeItem(this.flashcardsKey);
+      const key = this._getFlashcardsKey(languageCode);
+      localStorage.removeItem(key);
     } catch (error) {
       console.error('Failed to clear flashcards from localStorage:', error);
     }
   }
+
+  // Clear all flashcards for all languages
+  clearAllFlashcards() {
+    try {
+      // Clear the base key
+      localStorage.removeItem(this.flashcardsKey);
+      // Clear language-specific keys
+      const languages = ['es', 'ja', 'fr'];
+      languages.forEach((lang) => {
+        localStorage.removeItem(this._getFlashcardsKey(lang));
+      });
+    } catch (error) {
+      console.error('Failed to clear all flashcards from localStorage:', error);
+    }
+  }
 }
diff --git a/frontend/styles/main.css b/frontend/styles/main.css
index 4f2e0b3..00c0f6e 100644
--- a/frontend/styles/main.css
+++ b/frontend/styles/main.css
@@ -43,6 +43,50 @@ body {
     color: #1a1a1a;
 }
 
+.header-controls {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+}
+
+.language-selector {
+    display: flex;
+    align-items: center;
+}
+
+.language-dropdown {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 8px 12px;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    background: #ffffff;
+    color: #1a1a1a;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    min-width: 140px;
+    appearance: none;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%236b7280' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M6 9l6 6 6-6'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 12px center;
+    padding-right: 32px;
+}
+
+.language-dropdown:hover:not(:disabled) {
+    border-color: #1a1a1a;
+}
+
+.language-dropdown:focus {
+    outline: none;
+    border-color: #1a1a1a;
+    box-shadow: 0 0 0 2px rgba(26, 26, 26, 0.1);
+}
+
+.language-dropdown:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
 .status-indicator {
     display: flex;
     align-items: center;
@@ -383,7 +427,8 @@ body {
     transform: rotateY(180deg);
 }
 
-.flashcard-spanish {
+.flashcard-spanish,
+.flashcard-target-word {
     font-size: 32px;
     font-weight: 700;
     text-align: center;
@@ -441,7 +486,8 @@ body {
         scroll-snap-align: start;
     }
     
-    .flashcard-spanish {
+    .flashcard-spanish,
+    .flashcard-target-word {
         font-size: 24px;
     }
     
diff --git a/package-lock.json b/package-lock.json
index 626100b..7bdb6aa 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -32,7 +32,7 @@
         "typescript-eslint": "^8.0.0"
       },
       "engines": {
-        "node": ">=18.0.0",
+        "node": ">=20.0.0",
         "npm": ">=9.0.0"
       }
     },
@@ -1513,7 +1513,6 @@
       "integrity": "sha512-tK3GPFWbirvNgsNKto+UmB/cRtn6TZfyw0D6IKrW55n6Vbs7KJoZtI//kpTKzE/DUmmnAFD8/Ca46s7Obs92/w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.46.4",
         "@typescript-eslint/types": "8.46.4",
@@ -1863,7 +1862,6 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2893,7 +2891,6 @@
       "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -2954,7 +2951,6 @@
       "integrity": "sha512-iI1f+D2ViGn+uvv5HuHVUamg8ll4tN+JRHGc6IJi4TP9Kl976C57fzPXgseXNs8v0iA8aSJpHsTWjDb9QJamGQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -4915,7 +4911,6 @@
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -5900,7 +5895,6 @@
       "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"

From b756438b9f8eef21433c7003a1c39ddc5bcb4890 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Mon, 29 Dec 2025 17:58:17 -0800
Subject: [PATCH 02/49] Feat: port to long-running 0.9 graph

---
 backend/components/audio/audio_utils.ts       |   71 +
 .../audio/multimodal_stream_manager.ts        |  135 +
 .../components/graphs/conversation-graph.ts   |  305 ++
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  724 ++++
 .../nodes/dialog_prompt_builder_node.ts       |   94 +
 .../graphs/nodes/interaction_queue_node.ts    |  167 +
 .../graphs/nodes/state_update_node.ts         |   68 +
 .../graphs/nodes/text_input_node.ts           |   61 +
 .../graphs/nodes/transcript_extractor_node.ts |   51 +
 .../graphs/nodes/tts_request_builder_node.ts  |   64 +
 backend/graphs/conversation-graph.ts          |  267 --
 backend/graphs/flashcard-graph.ts             |   18 +-
 backend/graphs/introduction-state-graph.ts    |   11 +-
 backend/helpers/audio-processor.ts            |  790 ----
 backend/helpers/connection-manager.ts         |  580 +++
 backend/helpers/silero-vad.ts                 |  287 --
 backend/server.ts                             |  414 +--
 backend/types/index.ts                        |   81 +
 backend/types/settings.ts                     |   47 +
 flashcard-graph.json                          |   95 -
 frontend/js/audio-player.js                   |   62 +-
 frontend/js/chat-ui.js                        |  116 +
 frontend/js/main.js                           |   13 +-
 frontend/js/translator.js                     |   90 +
 frontend/js/websocket-client.js               |    9 +
 frontend/styles/main.css                      |  104 +
 package-lock.json                             | 1499 +-------
 package.json                                  |    2 +-
 realtime-service/.env-sample                  |   39 +
 realtime-service/Makefile                     |   53 +
 realtime-service/README.md                    |   91 +
 realtime-service/__tests__/README.md          |  469 +++
 realtime-service/__tests__/api/README.md      |  312 ++
 .../__tests__/api/realtime-api.spec.ts        |  885 +++++
 .../__tests__/api/websocket-server-helper.ts  |  133 +
 .../__tests__/api/websocket-test-helper.ts    |  311 ++
 realtime-service/__tests__/config.ts          |    8 +
 realtime-service/__tests__/setup.ts           |    9 +
 realtime-service/__tests__/test-setup.ts      |   32 +
 .../__tests__/utils/graph-test-helpers.ts     |   71 +
 .../__tests__/utils/mock-helpers.ts           |   93 +
 realtime-service/jest.config.js               |   34 +
 realtime-service/load-tests/README.md         |   61 +
 realtime-service/load-tests/load_test.js      |  425 +++
 realtime-service/load-tests/package.json      |   30 +
 realtime-service/mock/echo_ws_server.go       |   50 +
 realtime-service/package-lock.json            |   33 +
 realtime-service/package.json                 |   26 +
 realtime-service/src/.gitignore               |   32 +
 realtime-service/src/REALTIME_API.md          |  313 ++
 realtime-service/src/components/app.ts        |   78 +
 .../src/components/audio/audio_utils.ts       |   91 +
 .../audio/multimodal_stream_manager.ts        |  125 +
 .../audio/realtime_audio_handler.ts           |  213 ++
 .../src/components/graphs/graph.ts            |  308 ++
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  855 +++++
 .../nodes/dialog_prompt_builder_node.ts       |   87 +
 .../graphs/nodes/interaction_queue_node.ts    |  178 +
 .../graphs/nodes/state_update_node.ts         |   67 +
 .../graphs/nodes/text_input_node.ts           |   75 +
 .../graphs/nodes/text_output_stream_node.ts   |   29 +
 .../graphs/nodes/transcript_extractor_node.ts |   63 +
 .../graphs/nodes/tts_request_builder_node.ts  |   64 +
 .../graphs/realtime_graph_executor.ts         | 1180 ++++++
 .../realtime/realtime_event_factory.ts        |  499 +++
 .../realtime/realtime_message_handler.ts      |  168 +
 .../realtime/realtime_session_manager.ts      |  508 +++
 .../src/components/runtime_app_manager.ts     |  140 +
 realtime-service/src/config.ts                |   15 +
 realtime-service/src/helpers.ts               |   65 +
 realtime-service/src/index.ts                 |  319 ++
 realtime-service/src/log-helpers.ts           |   88 +
 realtime-service/src/logger.ts                |   66 +
 realtime-service/src/package-lock.json        | 3273 +++++++++++++++++
 realtime-service/src/package.json             |   36 +
 realtime-service/src/tsconfig.json            |   23 +
 realtime-service/src/types/index.ts           |  108 +
 realtime-service/src/types/realtime.ts        |  526 +++
 realtime-service/src/types/settings.ts        |   45 +
 realtime-service/tsconfig.test.json           |   21 +
 realtime-service/yarn.lock                    |    8 +
 81 files changed, 15924 insertions(+), 3132 deletions(-)
 create mode 100644 backend/components/audio/audio_utils.ts
 create mode 100644 backend/components/audio/multimodal_stream_manager.ts
 create mode 100644 backend/components/graphs/conversation-graph.ts
 create mode 100644 backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts
 create mode 100644 backend/components/graphs/nodes/dialog_prompt_builder_node.ts
 create mode 100644 backend/components/graphs/nodes/interaction_queue_node.ts
 create mode 100644 backend/components/graphs/nodes/state_update_node.ts
 create mode 100644 backend/components/graphs/nodes/text_input_node.ts
 create mode 100644 backend/components/graphs/nodes/transcript_extractor_node.ts
 create mode 100644 backend/components/graphs/nodes/tts_request_builder_node.ts
 delete mode 100644 backend/graphs/conversation-graph.ts
 delete mode 100644 backend/helpers/audio-processor.ts
 create mode 100644 backend/helpers/connection-manager.ts
 delete mode 100644 backend/helpers/silero-vad.ts
 create mode 100644 backend/types/index.ts
 create mode 100644 backend/types/settings.ts
 delete mode 100644 flashcard-graph.json
 create mode 100644 frontend/js/translator.js
 create mode 100644 realtime-service/.env-sample
 create mode 100644 realtime-service/Makefile
 create mode 100644 realtime-service/README.md
 create mode 100644 realtime-service/__tests__/README.md
 create mode 100644 realtime-service/__tests__/api/README.md
 create mode 100644 realtime-service/__tests__/api/realtime-api.spec.ts
 create mode 100644 realtime-service/__tests__/api/websocket-server-helper.ts
 create mode 100644 realtime-service/__tests__/api/websocket-test-helper.ts
 create mode 100644 realtime-service/__tests__/config.ts
 create mode 100644 realtime-service/__tests__/setup.ts
 create mode 100644 realtime-service/__tests__/test-setup.ts
 create mode 100644 realtime-service/__tests__/utils/graph-test-helpers.ts
 create mode 100644 realtime-service/__tests__/utils/mock-helpers.ts
 create mode 100644 realtime-service/jest.config.js
 create mode 100644 realtime-service/load-tests/README.md
 create mode 100644 realtime-service/load-tests/load_test.js
 create mode 100644 realtime-service/load-tests/package.json
 create mode 100644 realtime-service/mock/echo_ws_server.go
 create mode 100644 realtime-service/package-lock.json
 create mode 100644 realtime-service/package.json
 create mode 100644 realtime-service/src/.gitignore
 create mode 100644 realtime-service/src/REALTIME_API.md
 create mode 100644 realtime-service/src/components/app.ts
 create mode 100644 realtime-service/src/components/audio/audio_utils.ts
 create mode 100644 realtime-service/src/components/audio/multimodal_stream_manager.ts
 create mode 100644 realtime-service/src/components/audio/realtime_audio_handler.ts
 create mode 100644 realtime-service/src/components/graphs/graph.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/state_update_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/text_input_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
 create mode 100644 realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
 create mode 100644 realtime-service/src/components/graphs/realtime_graph_executor.ts
 create mode 100644 realtime-service/src/components/realtime/realtime_event_factory.ts
 create mode 100644 realtime-service/src/components/realtime/realtime_message_handler.ts
 create mode 100644 realtime-service/src/components/realtime/realtime_session_manager.ts
 create mode 100644 realtime-service/src/components/runtime_app_manager.ts
 create mode 100644 realtime-service/src/config.ts
 create mode 100644 realtime-service/src/helpers.ts
 create mode 100644 realtime-service/src/index.ts
 create mode 100644 realtime-service/src/log-helpers.ts
 create mode 100644 realtime-service/src/logger.ts
 create mode 100644 realtime-service/src/package-lock.json
 create mode 100644 realtime-service/src/package.json
 create mode 100644 realtime-service/src/tsconfig.json
 create mode 100644 realtime-service/src/types/index.ts
 create mode 100644 realtime-service/src/types/realtime.ts
 create mode 100644 realtime-service/src/types/settings.ts
 create mode 100644 realtime-service/tsconfig.test.json
 create mode 100644 realtime-service/yarn.lock

diff --git a/backend/components/audio/audio_utils.ts b/backend/components/audio/audio_utils.ts
new file mode 100644
index 0000000..f404a38
--- /dev/null
+++ b/backend/components/audio/audio_utils.ts
@@ -0,0 +1,71 @@
+/**
+ * Audio utility functions for format conversion
+ */
+
+/**
+ * Convert Float32Array audio data to Int16Array (PCM16)
+ */
+export function float32ToPCM16(float32Data: Float32Array): Int16Array {
+  const pcm16 = new Int16Array(float32Data.length);
+  for (let i = 0; i < float32Data.length; i++) {
+    // Clamp to [-1, 1] range and convert to Int16 range [-32768, 32767]
+    const s = Math.max(-1, Math.min(1, float32Data[i]));
+    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+  }
+  return pcm16;
+}
+
+/**
+ * Convert Int16Array (PCM16) to Float32Array
+ */
+export function pcm16ToFloat32(pcm16Data: Int16Array): Float32Array {
+  const float32 = new Float32Array(pcm16Data.length);
+  for (let i = 0; i < pcm16Data.length; i++) {
+    float32[i] = pcm16Data[i] / 32768.0;
+  }
+  return float32;
+}
+
+/**
+ * Convert audio data to PCM16 base64 string for WebSocket transmission
+ */
+export function convertToPCM16Base64(
+  audioData: number[] | Float32Array | string | undefined,
+  _sampleRate: number | undefined,
+  _logPrefix: string = 'Audio'
+): string | null {
+  if (!audioData) {
+    return null;
+  }
+
+  let base64Data: string;
+
+  if (typeof audioData === 'string') {
+    // Already base64 encoded
+    base64Data = audioData;
+  } else {
+    // Convert Float32 array to PCM16 base64
+    const float32Data = Array.isArray(audioData)
+      ? new Float32Array(audioData)
+      : audioData;
+    const pcm16Data = float32ToPCM16(float32Data);
+    base64Data = Buffer.from(pcm16Data.buffer).toString('base64');
+  }
+
+  return base64Data;
+}
+
+/**
+ * Decode base64 audio to Float32Array
+ * Note: Node.js Buffer objects share ArrayBuffers with offsets, so we need to copy
+ */
+export function decodeBase64ToFloat32(base64Audio: string): Float32Array {
+  const buffer = Buffer.from(base64Audio, 'base64');
+  // Create a clean copy to avoid Node.js Buffer's internal ArrayBuffer sharing
+  const cleanArray = new Uint8Array(buffer.length);
+  for (let i = 0; i < buffer.length; i++) {
+    cleanArray[i] = buffer[i];
+  }
+  const int16Array = new Int16Array(cleanArray.buffer);
+  return pcm16ToFloat32(int16Array);
+}
diff --git a/backend/components/audio/multimodal_stream_manager.ts b/backend/components/audio/multimodal_stream_manager.ts
new file mode 100644
index 0000000..212fe55
--- /dev/null
+++ b/backend/components/audio/multimodal_stream_manager.ts
@@ -0,0 +1,135 @@
+/**
+ * Manages a stream of multimodal content (audio and/or text) that can be fed
+ * asynchronously as data arrives from websocket connections.
+ *
+ * This unifies audio and text streaming into a single interface that always
+ * yields MultimodalContent, making it compatible with the 0.9 graph architecture.
+ */
+
+import { GraphTypes } from '@inworld/runtime/graph';
+
+export interface AudioChunkInterface {
+  data: number[] | Float32Array;
+  sampleRate: number;
+}
+
+export class MultimodalStreamManager {
+  private queue: GraphTypes.MultimodalContent[] = [];
+  private waitingResolvers: Array<
+    (value: IteratorResult<GraphTypes.MultimodalContent>) => void
+  > = [];
+  private ended = false;
+
+  /**
+   * Add an audio chunk to the stream (wrapped in MultimodalContent)
+   */
+  pushAudio(chunk: AudioChunkInterface): void {
+    if (this.ended) {
+      return;
+    }
+
+    // Create GraphTypes.Audio object and wrap in MultimodalContent
+    const audioData = new GraphTypes.Audio({
+      data: Array.isArray(chunk.data) ? chunk.data : Array.from(chunk.data),
+      sampleRate: chunk.sampleRate,
+    });
+    const multimodalContent = new GraphTypes.MultimodalContent({
+      audio: audioData,
+    });
+
+    this.pushContent(multimodalContent);
+  }
+
+  /**
+   * Add text to the stream (wrapped in MultimodalContent)
+   */
+  pushText(text: string): void {
+    if (this.ended) {
+      return;
+    }
+
+    const multimodalContent = new GraphTypes.MultimodalContent({ text });
+    this.pushContent(multimodalContent);
+  }
+
+  /**
+   * Internal method to push MultimodalContent to the stream
+   */
+  private pushContent(content: GraphTypes.MultimodalContent): void {
+    // If there are waiting consumers, resolve immediately
+    if (this.waitingResolvers.length > 0) {
+      const resolve = this.waitingResolvers.shift()!;
+      resolve({ value: content, done: false });
+    } else {
+      // Otherwise, queue the content
+      this.queue.push(content);
+    }
+  }
+
+  /**
+   * Mark the stream as ended
+   */
+  end(): void {
+    console.log('[MultimodalStreamManager] Ending stream');
+    this.ended = true;
+
+    // Resolve all waiting consumers with done signal
+    while (this.waitingResolvers.length > 0) {
+      const resolve = this.waitingResolvers.shift()!;
+      resolve({ value: undefined as unknown as GraphTypes.MultimodalContent, done: true });
+    }
+  }
+
+  /**
+   * Create an async iterator for the stream
+   */
+  async *createStream(): AsyncIterableIterator<GraphTypes.MultimodalContent> {
+    while (true) {
+      // If stream ended and queue is empty, we're done
+      if (this.ended && this.queue.length === 0) {
+        console.log('[MultimodalStreamManager] Stream iteration complete');
+        return;
+      }
+
+      // If we have queued content, yield it immediately
+      if (this.queue.length > 0) {
+        const content = this.queue.shift()!;
+        yield content;
+        continue;
+      }
+
+      // If stream ended but we just exhausted the queue, we're done
+      if (this.ended) {
+        console.log('[MultimodalStreamManager] Stream iteration complete');
+        return;
+      }
+
+      // Otherwise, wait for new content
+      const result = await new Promise<
+        IteratorResult<GraphTypes.MultimodalContent>
+      >((resolve) => {
+        this.waitingResolvers.push(resolve);
+      });
+
+      if (result.done) {
+        return;
+      }
+
+      yield result.value;
+    }
+  }
+
+  /**
+   * Check if the stream has ended
+   */
+  isEnded(): boolean {
+    return this.ended;
+  }
+
+  /**
+   * Get the current queue length (for debugging)
+   */
+  getQueueLength(): number {
+    return this.queue.length;
+  }
+}
diff --git a/backend/components/graphs/conversation-graph.ts b/backend/components/graphs/conversation-graph.ts
new file mode 100644
index 0000000..b873b7d
--- /dev/null
+++ b/backend/components/graphs/conversation-graph.ts
@@ -0,0 +1,305 @@
+/**
+ * Conversation Graph for Language Learning App - Inworld Runtime 0.9
+ *
+ * This is a long-running circular graph that:
+ * - Processes continuous audio streams via AssemblyAI STT with built-in VAD
+ * - Queues interactions for sequential processing
+ * - Uses language-specific prompts and TTS voices
+ * - Loops back for the next interaction automatically
+ *
+ * Graph Flow:
+ * AudioInput → AssemblyAI STT (loop) → TranscriptExtractor → InteractionQueue
+ *    → TextInput → DialogPromptBuilder → LLM → TextChunking → TTSRequestBuilder → TTS
+ *    → TextAggregator → StateUpdate → (loop back to InteractionQueue)
+ */
+
+import {
+  Graph,
+  GraphBuilder,
+  ProxyNode,
+  RemoteLLMChatNode,
+  RemoteTTSNode,
+  TextChunkingNode,
+  TextAggregatorNode,
+} from '@inworld/runtime/graph';
+
+import { AssemblyAISTTWebSocketNode } from './nodes/assembly_ai_stt_ws_node.js';
+import { DialogPromptBuilderNode } from './nodes/dialog_prompt_builder_node.js';
+import { InteractionQueueNode } from './nodes/interaction_queue_node.js';
+import { StateUpdateNode } from './nodes/state_update_node.js';
+import { TextInputNode } from './nodes/text_input_node.js';
+import { TranscriptExtractorNode } from './nodes/transcript_extractor_node.js';
+import { TTSRequestBuilderNode } from './nodes/tts_request_builder_node.js';
+import {
+  ConnectionsMap,
+  TextInput,
+  INPUT_SAMPLE_RATE,
+  TTS_SAMPLE_RATE,
+} from '../../types/index.js';
+import {
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../../config/languages.js';
+import { getAssemblyAISettingsForEagerness } from '../../types/settings.js';
+
+export interface ConversationGraphConfig {
+  assemblyAIApiKey: string;
+  connections: ConnectionsMap;
+  defaultLanguageCode?: string;
+}
+
+/**
+ * Wrapper class for the conversation graph
+ * Provides access to the graph and the AssemblyAI node for session management
+ */
+export class ConversationGraphWrapper {
+  graph: Graph;
+  assemblyAINode: AssemblyAISTTWebSocketNode;
+
+  private constructor(params: {
+    graph: Graph;
+    assemblyAINode: AssemblyAISTTWebSocketNode;
+  }) {
+    this.graph = params.graph;
+    this.assemblyAINode = params.assemblyAINode;
+  }
+
+  async destroy(): Promise<void> {
+    await this.assemblyAINode.destroy();
+    await this.graph.stop();
+  }
+
+  /**
+   * Create the conversation graph
+   */
+  static create(config: ConversationGraphConfig): ConversationGraphWrapper {
+    const {
+      connections,
+      assemblyAIApiKey,
+      defaultLanguageCode = DEFAULT_LANGUAGE_CODE,
+    } = config;
+    const langConfig = getLanguageConfig(defaultLanguageCode);
+    const postfix = `-lang-learning`;
+
+    console.log(
+      `[ConversationGraph] Creating graph for ${langConfig.name} (${defaultLanguageCode})`
+    );
+
+    // ============================================================
+    // Create Nodes
+    // ============================================================
+
+    // Start node (audio input proxy)
+    const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
+
+    // AssemblyAI STT with built-in VAD
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness('medium');
+    const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
+      id: `assembly-ai-stt-ws-node${postfix}`,
+      config: {
+        apiKey: assemblyAIApiKey,
+        connections: connections,
+        sampleRate: INPUT_SAMPLE_RATE,
+        formatTurns: true,
+        endOfTurnConfidenceThreshold:
+          turnDetectionSettings.endOfTurnConfidenceThreshold,
+        minEndOfTurnSilenceWhenConfident:
+          turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
+        maxTurnSilence: turnDetectionSettings.maxTurnSilence,
+        language: defaultLanguageCode.split('-')[0], // 'es' from 'es-MX'
+      },
+    });
+
+    const transcriptExtractorNode = new TranscriptExtractorNode({
+      id: `transcript-extractor-node${postfix}`,
+      reportToClient: true,
+    });
+
+    const interactionQueueNode = new InteractionQueueNode({
+      id: `interaction-queue-node${postfix}`,
+      connections,
+      reportToClient: false,
+    });
+
+    const textInputNode = new TextInputNode({
+      id: `text-input-node${postfix}`,
+      connections,
+      reportToClient: true,
+    });
+
+    const dialogPromptBuilderNode = new DialogPromptBuilderNode({
+      id: `dialog-prompt-builder-node${postfix}`,
+      connections,
+    });
+
+    // LLM Node - uses Inworld Runtime's remote LLM
+    const llmNode = new RemoteLLMChatNode({
+      id: `llm-node${postfix}`,
+      provider: 'openai',
+      modelName: 'gpt-4o-mini',
+      stream: true,
+      textGenerationConfig: {
+        maxNewTokens: 250,
+        maxPromptLength: 2000,
+        temperature: 1,
+        topP: 1,
+        repetitionPenalty: 1,
+        frequencyPenalty: 0,
+        presencePenalty: 0,
+      },
+      reportToClient: true,
+    });
+
+    const textChunkingNode = new TextChunkingNode({
+      id: `text-chunking-node${postfix}`,
+    });
+
+    const textAggregatorNode = new TextAggregatorNode({
+      id: `text-aggregator-node${postfix}`,
+    });
+
+    const stateUpdateNode = new StateUpdateNode({
+      id: `state-update-node${postfix}`,
+      connections,
+      reportToClient: true,
+    });
+
+    const ttsRequestBuilderNode = new TTSRequestBuilderNode({
+      id: `tts-request-builder-node${postfix}`,
+      connections,
+      defaultVoiceId: langConfig.ttsConfig.speakerId,
+      reportToClient: false,
+    });
+
+    const ttsNode = new RemoteTTSNode({
+      id: `tts-node${postfix}`,
+      speakerId: langConfig.ttsConfig.speakerId,
+      modelId: langConfig.ttsConfig.modelId,
+      sampleRate: TTS_SAMPLE_RATE,
+      temperature: langConfig.ttsConfig.temperature,
+      speakingRate: langConfig.ttsConfig.speakingRate,
+      languageCode: langConfig.ttsConfig.languageCode,
+      reportToClient: true,
+    });
+
+    // ============================================================
+    // Build the Graph
+    // ============================================================
+
+    const graphBuilder = new GraphBuilder({
+      id: `lang-learning-conversation-graph`,
+      enableRemoteConfig: false,
+    });
+
+    graphBuilder
+      // Add all nodes
+      .addNode(audioInputNode)
+      .addNode(assemblyAISTTNode)
+      .addNode(transcriptExtractorNode)
+      .addNode(interactionQueueNode)
+      .addNode(textInputNode)
+      .addNode(dialogPromptBuilderNode)
+      .addNode(llmNode)
+      .addNode(textChunkingNode)
+      .addNode(textAggregatorNode)
+      .addNode(ttsRequestBuilderNode)
+      .addNode(ttsNode)
+      .addNode(stateUpdateNode)
+
+      // ============================================================
+      // Audio Input Flow (STT with VAD)
+      // ============================================================
+      .addEdge(audioInputNode, assemblyAISTTNode)
+
+      // AssemblyAI loops back to itself while stream is active
+      .addEdge(assemblyAISTTNode, assemblyAISTTNode, {
+        condition: async (input: unknown) => {
+          const data = input as { stream_exhausted?: boolean };
+          return data?.stream_exhausted !== true;
+        },
+        loop: true,
+        optional: true,
+      })
+
+      // When interaction is complete, extract transcript
+      .addEdge(assemblyAISTTNode, transcriptExtractorNode, {
+        condition: async (input: unknown) => {
+          const data = input as { interaction_complete?: boolean };
+          return data?.interaction_complete === true;
+        },
+      })
+
+      // Transcript goes to interaction queue
+      .addEdge(transcriptExtractorNode, interactionQueueNode)
+
+      // ============================================================
+      // Processing Flow
+      // ============================================================
+
+      // InteractionQueue → TextInput only when there's text to process
+      .addEdge(interactionQueueNode, textInputNode, {
+        condition: (input: TextInput) => {
+          return Boolean(input.text && input.text.trim().length > 0);
+        },
+      })
+
+      // TextInput updates state and passes to prompt builder
+      .addEdge(textInputNode, dialogPromptBuilderNode)
+
+      // Also pass state to TTS builder for voice selection
+      .addEdge(textInputNode, ttsRequestBuilderNode)
+
+      // Prompt builder → LLM
+      .addEdge(dialogPromptBuilderNode, llmNode)
+
+      // LLM output splits: one for TTS, one for state update
+      .addEdge(llmNode, textChunkingNode)
+      .addEdge(llmNode, textAggregatorNode)
+
+      // Text chunking → TTS request builder → TTS
+      .addEdge(textChunkingNode, ttsRequestBuilderNode)
+      .addEdge(ttsRequestBuilderNode, ttsNode)
+
+      // Text aggregator → state update
+      .addEdge(textAggregatorNode, stateUpdateNode)
+
+      // ============================================================
+      // Loop Back
+      // ============================================================
+
+      // State update loops back to interaction queue for next turn
+      .addEdge(stateUpdateNode, interactionQueueNode, {
+        loop: true,
+        optional: true,
+      })
+
+      // ============================================================
+      // Start and End Nodes
+      // ============================================================
+      .setStartNode(audioInputNode)
+      .setEndNode(ttsNode);
+
+    const graph = graphBuilder.build();
+
+    console.log('[ConversationGraph] Graph built successfully');
+
+    return new ConversationGraphWrapper({
+      graph,
+      assemblyAINode: assemblyAISTTNode,
+    });
+  }
+}
+
+/**
+ * Legacy export for backwards compatibility during migration
+ */
+export function getConversationGraph(
+  _config: { apiKey: string },
+  _languageCode: string = DEFAULT_LANGUAGE_CODE
+): Graph {
+  console.warn(
+    '[ConversationGraph] getConversationGraph is deprecated. Use ConversationGraphWrapper.create() instead.'
+  );
+  // This won't work properly without connections, but maintains API compatibility
+  return null as unknown as Graph;
+}
diff --git a/backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts
new file mode 100644
index 0000000..ec4c7c5
--- /dev/null
+++ b/backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -0,0 +1,724 @@
+/**
+ * AssemblyAI Speech-to-Text WebSocket Node
+ *
+ * Processes continuous multimodal streams (audio and/or text) using Assembly.AI's
+ * streaming Speech-to-Text service via direct WebSocket connection.
+ *
+ * Features:
+ * - Persistent WebSocket connection per session
+ * - Automatic turn detection (VAD built-in)
+ * - Multi-language support
+ * - Partial transcript updates
+ */
+
+import { DataStreamWithMetadata } from '@inworld/runtime';
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import WebSocket from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+
+import { Connection } from '../../../types/index.js';
+// Settings imported but used via constructor config
+// import { getAssemblyAISettingsForEagerness } from '../../../types/settings.js';
+import { float32ToPCM16 } from '../../audio/audio_utils.js';
+
+/**
+ * Configuration interface for AssemblyAISTTWebSocketNode
+ */
+export interface AssemblyAISTTWebSocketNodeConfig {
+  /** Assembly.AI API key */
+  apiKey: string;
+  /** Connections map to access session state */
+  connections: { [sessionId: string]: Connection };
+  /** Sample rate of the audio stream in Hz */
+  sampleRate?: number;
+  /** Enable turn formatting from Assembly.AI */
+  formatTurns?: boolean;
+  /** End of turn confidence threshold (0-1) */
+  endOfTurnConfidenceThreshold?: number;
+  /** Minimum silence duration when confident (in milliseconds) */
+  minEndOfTurnSilenceWhenConfident?: number;
+  /** Maximum turn silence (in milliseconds) */
+  maxTurnSilence?: number;
+  /** Default language code (e.g., 'en', 'es') */
+  language?: string;
+}
+
+/**
+ * Manages a persistent WebSocket connection to Assembly.AI for a single session.
+ */
+class AssemblyAISession {
+  private ws: WebSocket | null = null;
+  private wsReady: boolean = false;
+  private wsConnectionPromise: Promise<void> | null = null;
+
+  public assemblySessionId: string = '';
+  public sessionExpiresAt: number = 0;
+  public shouldStopProcessing: boolean = false;
+
+  private inactivityTimeout: NodeJS.Timeout | null = null;
+  private lastActivityTime: number = Date.now();
+  private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
+
+  // Audio buffering for AssemblyAI's chunk size requirements (50-1000ms)
+  private audioBuffer: Int16Array = new Int16Array(0);
+  // Buffer to ~100ms worth of audio before sending (1600 samples at 16kHz)
+  private readonly MIN_SAMPLES_TO_SEND = 1600;
+
+  constructor(
+    public readonly sessionId: string,
+    private apiKey: string,
+    private url: string,
+    private onCleanup: (sessionId: string) => void
+  ) {}
+
+  /**
+   * Ensure WebSocket connection is ready, reconnecting if needed
+   */
+  public async ensureConnection(): Promise<void> {
+    const now = Math.floor(Date.now() / 1000);
+    const isExpired =
+      this.sessionExpiresAt > 0 && now >= this.sessionExpiresAt;
+
+    if (
+      !this.ws ||
+      !this.wsReady ||
+      this.ws.readyState !== WebSocket.OPEN ||
+      isExpired
+    ) {
+      if (isExpired) {
+        console.log(
+          `[AssemblyAI] Session ${this.sessionId} expired, reconnecting`
+        );
+      }
+      this.closeWebSocket();
+      this.initializeWebSocket();
+    }
+
+    if (this.wsConnectionPromise) {
+      await this.wsConnectionPromise;
+    }
+
+    this.shouldStopProcessing = false;
+    this.resetInactivityTimer();
+  }
+
+  private initializeWebSocket(): void {
+    console.log(`[AssemblyAI] Initializing WebSocket for session ${this.sessionId}`);
+
+    this.wsConnectionPromise = new Promise<void>((resolve, reject) => {
+      this.ws = new WebSocket(this.url, {
+        headers: { Authorization: this.apiKey },
+      });
+
+      this.ws.on('open', () => {
+        console.log(`[AssemblyAI] WebSocket opened for session ${this.sessionId}`);
+        this.wsReady = true;
+        resolve();
+      });
+
+      this.ws.on('message', (data: WebSocket.Data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          if (message.type === 'Begin') {
+            this.assemblySessionId = message.id || message.session_id || '';
+            this.sessionExpiresAt = message.expires_at || 0;
+            console.log(
+              `[AssemblyAI] Session began: ${this.assemblySessionId}`
+            );
+          }
+        } catch {
+          // Ignore parsing errors
+        }
+      });
+
+      this.ws.on('error', (error: Error) => {
+        console.error(`[AssemblyAI] WebSocket error:`, error);
+        this.wsReady = false;
+        reject(error);
+      });
+
+      this.ws.on('close', (code: number, reason: Buffer) => {
+        console.log(
+          `[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`
+        );
+        this.wsReady = false;
+      });
+    });
+  }
+
+  public onMessage(listener: (data: WebSocket.Data) => void): void {
+    if (this.ws) {
+      this.ws.on('message', listener);
+    }
+  }
+
+  public offMessage(listener: (data: WebSocket.Data) => void): void {
+    if (this.ws) {
+      this.ws.off('message', listener);
+    }
+  }
+
+  public sendAudio(pcm16Data: Int16Array): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    // Append new audio to buffer
+    const newBuffer = new Int16Array(this.audioBuffer.length + pcm16Data.length);
+    newBuffer.set(this.audioBuffer, 0);
+    newBuffer.set(pcm16Data, this.audioBuffer.length);
+    this.audioBuffer = newBuffer;
+
+    // Send if we have enough samples (100ms worth at 16kHz = 1600 samples)
+    if (this.audioBuffer.length >= this.MIN_SAMPLES_TO_SEND) {
+      this.ws.send(Buffer.from(this.audioBuffer.buffer));
+      this.audioBuffer = new Int16Array(0);
+      this.resetInactivityTimer();
+    }
+  }
+
+  /**
+   * Flush any remaining buffered audio (call before closing)
+   */
+  public flushAudio(): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.audioBuffer.length > 0) {
+      // Pad to minimum size if needed
+      if (this.audioBuffer.length < 800) {
+        // Pad to at least 50ms (800 samples)
+        const paddedBuffer = new Int16Array(800);
+        paddedBuffer.set(this.audioBuffer, 0);
+        this.ws.send(Buffer.from(paddedBuffer.buffer));
+      } else {
+        this.ws.send(Buffer.from(this.audioBuffer.buffer));
+      }
+      this.audioBuffer = new Int16Array(0);
+    }
+  }
+
+  private resetInactivityTimer(): void {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+    }
+    this.lastActivityTime = Date.now();
+    this.inactivityTimeout = setTimeout(() => {
+      this.closeDueToInactivity();
+    }, this.INACTIVITY_TIMEOUT_MS);
+  }
+
+  private closeDueToInactivity(): void {
+    const inactiveFor = Date.now() - this.lastActivityTime;
+    console.log(
+      `[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`
+    );
+    this.shouldStopProcessing = true;
+    this.close();
+    this.onCleanup(this.sessionId);
+  }
+
+  private closeWebSocket(): void {
+    if (this.ws) {
+      try {
+        this.ws.removeAllListeners();
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close();
+        }
+      } catch (e) {
+        console.warn('[AssemblyAI] Error closing socket:', e);
+      }
+      this.ws = null;
+      this.wsReady = false;
+    }
+  }
+
+  public async close(): Promise<void> {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+    }
+
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify({ type: 'Terminate' }));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } catch {
+        // Ignore
+      }
+    }
+
+    this.closeWebSocket();
+  }
+}
+
+/**
+ * AssemblyAI STT WebSocket Node for the Inworld runtime graph
+ */
+export class AssemblyAISTTWebSocketNode extends CustomNode {
+  private apiKey: string;
+  private connections: { [sessionId: string]: Connection };
+  private sampleRate: number;
+  private formatTurns: boolean;
+  private endOfTurnConfidenceThreshold: number;
+  private minEndOfTurnSilenceWhenConfident: number;
+  private maxTurnSilence: number;
+  private defaultLanguage: string;
+  private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
+
+  private sessions: Map<string, AssemblyAISession> = new Map();
+  private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
+  private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
+
+  constructor(props: { id?: string; config: AssemblyAISTTWebSocketNodeConfig }) {
+    const { config, ...nodeProps } = props;
+
+    if (!config.apiKey) {
+      throw new Error('AssemblyAISTTWebSocketNode requires an API key.');
+    }
+    if (!config.connections) {
+      throw new Error('AssemblyAISTTWebSocketNode requires a connections object.');
+    }
+
+    super({
+      id: nodeProps.id || 'assembly-ai-stt-ws-node',
+      executionConfig: {
+        sampleRate: config.sampleRate || 16000,
+        formatTurns: config.formatTurns !== false,
+        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold || 0.4,
+        minEndOfTurnSilenceWhenConfident:
+          config.minEndOfTurnSilenceWhenConfident || 400,
+        maxTurnSilence: config.maxTurnSilence || 1280,
+        language: config.language || 'es',
+      },
+    });
+
+    this.apiKey = config.apiKey;
+    this.connections = config.connections;
+    this.sampleRate = config.sampleRate || 16000;
+    this.formatTurns = config.formatTurns !== false;
+    this.endOfTurnConfidenceThreshold =
+      config.endOfTurnConfidenceThreshold || 0.4;
+    this.minEndOfTurnSilenceWhenConfident =
+      config.minEndOfTurnSilenceWhenConfident || 400;
+    this.maxTurnSilence = config.maxTurnSilence || 1280;
+    this.defaultLanguage = config.language || 'es';
+
+    console.log(
+      `[AssemblyAI] Configured with [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.defaultLanguage}]`
+    );
+  }
+
+  /**
+   * Build WebSocket URL with query parameters
+   * Dynamically uses connection.state.languageCode if available
+   */
+  private buildWebSocketUrl(sessionId?: string): string {
+    let endOfTurnThreshold = this.endOfTurnConfidenceThreshold;
+    let minSilenceWhenConfident = this.minEndOfTurnSilenceWhenConfident;
+    let maxSilence = this.maxTurnSilence;
+    let language = this.defaultLanguage;
+
+    if (sessionId) {
+      const connection = this.connections[sessionId];
+      // Get language from connection state (supports dynamic language switching)
+      if (connection?.state?.languageCode) {
+        // Extract base language code (e.g., 'es' from 'es-MX')
+        language = connection.state.languageCode.split('-')[0];
+      }
+    }
+
+    const params = new URLSearchParams({
+      sample_rate: this.sampleRate.toString(),
+      format_turns: this.formatTurns.toString(),
+      end_of_turn_confidence_threshold: endOfTurnThreshold.toString(),
+      min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
+      max_turn_silence: maxSilence.toString(),
+      language: language,
+    });
+
+    const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
+    console.log(
+      `[AssemblyAI] Connecting with [lang:${language}] [threshold:${endOfTurnThreshold}]`
+    );
+
+    return url;
+  }
+
+  /**
+   * Process multimodal stream and transcribe using Assembly.AI WebSocket
+   */
+  async process(
+    context: ProcessContext,
+    input0: AsyncIterableIterator<GraphTypes.MultimodalContent>,
+    input: DataStreamWithMetadata
+  ): Promise<DataStreamWithMetadata> {
+    const multimodalStream =
+      input !== undefined &&
+      input !== null &&
+      input instanceof DataStreamWithMetadata
+        ? (input.toStream() as unknown as AsyncIterableIterator<GraphTypes.MultimodalContent>)
+        : input0;
+
+    const sessionId = context.getDatastore().get('sessionId') as string;
+    const connection = this.connections[sessionId];
+
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId: ${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId: ${sessionId}`);
+    }
+
+    // Get or parse iteration from metadata
+    const metadata = input?.getMetadata?.() || {};
+    let previousIteration = (metadata.iteration as number) || 0;
+
+    if (
+      !connection.state.interactionId ||
+      connection.state.interactionId === ''
+    ) {
+      connection.state.interactionId = uuidv4();
+    }
+
+    const currentId = connection.state.interactionId;
+    const delimiterIndex = currentId.indexOf('#');
+
+    if (previousIteration === 0 && delimiterIndex !== -1) {
+      const iterationStr = currentId.substring(delimiterIndex + 1);
+      const parsedIteration = parseInt(iterationStr, 10);
+      if (!isNaN(parsedIteration) && /^\d+$/.test(iterationStr)) {
+        previousIteration = parsedIteration;
+      }
+    }
+
+    const iteration = previousIteration + 1;
+    const baseId =
+      delimiterIndex !== -1
+        ? currentId.substring(0, delimiterIndex)
+        : currentId;
+    const nextInteractionId = `${baseId}#${iteration}`;
+
+    console.log(`[AssemblyAI] Starting transcription [iteration:${iteration}]`);
+
+    // State tracking
+    let transcriptText = '';
+    let turnDetected = false;
+    let speechDetected = false;
+    let audioChunkCount = 0;
+    let totalAudioSamples = 0;
+    let isStreamExhausted = false;
+    let errorOccurred = false;
+    let errorMessage = '';
+    let maxDurationReached = false;
+    let isTextInput = false;
+    let textContent: string | undefined;
+
+    // Get or create session
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = new AssemblyAISession(
+        sessionId,
+        this.apiKey,
+        this.buildWebSocketUrl(sessionId),
+        (id) => this.sessions.delete(id)
+      );
+      this.sessions.set(sessionId, session);
+    }
+
+    // Promise to capture turn result
+    let turnResolve: (value: string) => void = () => {};
+    let turnReject: (error: Error) => void = () => {};
+    let turnCompleted = false;
+    const turnPromise = new Promise<string>((resolve, reject) => {
+      turnResolve = resolve;
+      turnReject = reject;
+    });
+    const turnPromiseWithState = turnPromise.then((value) => {
+      turnCompleted = true;
+      return value;
+    });
+
+    // AssemblyAI message handler
+    const messageHandler = (data: WebSocket.Data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        const msgType = message.type;
+
+        if (msgType === 'Turn') {
+          if (session?.shouldStopProcessing) {
+            return;
+          }
+
+          const transcript = message.transcript || '';
+          const utterance = message.utterance || '';
+          const isFinal = message.end_of_turn;
+
+          if (!transcript) return;
+
+          if (!isFinal) {
+            // Partial transcript
+            const textToSend = utterance || transcript;
+            if (textToSend) {
+              this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
+
+              if (connection?.onSpeechDetected && !speechDetected) {
+                console.log(`[AssemblyAI] Speech detected [iteration:${iteration}]`);
+                speechDetected = true;
+                connection.onSpeechDetected(nextInteractionId);
+              }
+            }
+            return;
+          }
+
+          // Final transcript
+          console.log(
+            `[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
+          );
+
+          transcriptText = transcript;
+          turnDetected = true;
+          if (session) session.shouldStopProcessing = true;
+          turnResolve(transcript);
+        } else if (msgType === 'Termination') {
+          console.log(`[AssemblyAI] Session terminated [iteration:${iteration}]`);
+        }
+      } catch (error) {
+        console.error(`[AssemblyAI] Error handling message:`, error);
+      }
+    };
+
+    try {
+      await session.ensureConnection();
+      session.onMessage(messageHandler);
+
+      // Process multimodal content (audio chunks)
+      const audioProcessingPromise = (async () => {
+        let maxDurationTimeout: NodeJS.Timeout | null = null;
+        try {
+          maxDurationTimeout = setTimeout(() => {
+            maxDurationReached = true;
+          }, this.MAX_TRANSCRIPTION_DURATION_MS);
+
+          while (true) {
+            if (session?.shouldStopProcessing) break;
+            if (maxDurationReached && !transcriptText) {
+              console.warn(
+                `[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`
+              );
+              break;
+            }
+
+            const result = await multimodalStream.next();
+
+            if (result.done) {
+              console.log(
+                `[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`
+              );
+              isStreamExhausted = true;
+              break;
+            }
+
+            if (session?.shouldStopProcessing) break;
+
+            const content = result.value as GraphTypes.MultimodalContent;
+
+            // Handle text input
+            if (content.text !== undefined && content.text !== null) {
+              console.log(
+                `[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`
+              );
+              isTextInput = true;
+              textContent = content.text;
+              transcriptText = content.text;
+              turnDetected = true;
+              if (session) session.shouldStopProcessing = true;
+              turnResolve(transcriptText);
+              break;
+            }
+
+            // Extract audio from MultimodalContent
+            if (content.audio === undefined || content.audio === null) {
+              continue;
+            }
+
+            const audioData = content.audio.data;
+            if (!audioData || audioData.length === 0) {
+              continue;
+            }
+
+            const float32Data = Array.isArray(audioData)
+              ? new Float32Array(audioData)
+              : audioData;
+
+            audioChunkCount++;
+            totalAudioSamples += float32Data.length;
+
+            const pcm16Data = float32ToPCM16(float32Data);
+            session?.sendAudio(pcm16Data);
+          }
+        } catch (error) {
+          console.error(`[AssemblyAI] Error processing audio:`, error);
+          errorOccurred = true;
+          errorMessage = error instanceof Error ? error.message : String(error);
+          throw error;
+        } finally {
+          if (maxDurationTimeout) {
+            clearTimeout(maxDurationTimeout);
+          }
+          // Flush any remaining buffered audio
+          session?.flushAudio();
+        }
+      })();
+
+      const raceResult = await Promise.race([
+        turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
+        audioProcessingPromise.then(() => ({ winner: 'audio' as const })),
+      ]);
+
+      if (
+        raceResult.winner === 'audio' &&
+        !turnCompleted &&
+        !maxDurationReached
+      ) {
+        console.log(
+          `[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`
+        );
+
+        // Send silence to keep connection alive
+        const silenceIntervalMs = 100;
+        const silenceSamples = Math.floor(
+          (silenceIntervalMs / 1000) * this.sampleRate
+        );
+        const silenceFrame = new Int16Array(silenceSamples);
+        const silenceTimer = setInterval(() => {
+          if (session && !session.shouldStopProcessing) {
+            session.sendAudio(silenceFrame);
+          }
+        }, silenceIntervalMs);
+
+        const timeoutPromise = new Promise<{ winner: 'timeout' }>((resolve) =>
+          setTimeout(
+            () => resolve({ winner: 'timeout' }),
+            this.TURN_COMPLETION_TIMEOUT_MS
+          )
+        );
+
+        const waitResult = await Promise.race([
+          turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
+          timeoutPromise,
+        ]);
+
+        clearInterval(silenceTimer);
+
+        if (waitResult.winner === 'timeout' && !turnCompleted) {
+          console.warn(`[AssemblyAI] Timed out waiting for turn`);
+          turnReject?.(new Error('Timed out waiting for turn completion'));
+        }
+      }
+
+      await audioProcessingPromise.catch(() => {});
+
+      console.log(
+        `[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`
+      );
+
+      if (turnDetected) {
+        connection.state.interactionId = '';
+      }
+
+      // Tag the stream for runtime
+      const taggedStream = Object.assign(multimodalStream, {
+        type: 'MultimodalContent',
+        abort: () => {},
+        getMetadata: () => ({}),
+      });
+
+      return new DataStreamWithMetadata(taggedStream, {
+        elementType: 'MultimodalContent',
+        iteration: iteration,
+        interactionId: nextInteractionId,
+        session_id: sessionId,
+        assembly_session_id: session.assemblySessionId,
+        transcript: transcriptText,
+        turn_detected: turnDetected,
+        audio_chunk_count: audioChunkCount,
+        total_audio_samples: totalAudioSamples,
+        sample_rate: this.sampleRate,
+        stream_exhausted: isStreamExhausted,
+        interaction_complete: turnDetected && transcriptText.length > 0,
+        error_occurred: errorOccurred,
+        error_message: errorMessage,
+        is_text_input: isTextInput,
+        text_content: textContent,
+      });
+    } catch (error) {
+      console.error(`[AssemblyAI] Transcription failed [iteration:${iteration}]:`, error);
+
+      const taggedStream = Object.assign(multimodalStream, {
+        type: 'MultimodalContent',
+        abort: () => {},
+        getMetadata: () => ({}),
+      });
+
+      return new DataStreamWithMetadata(taggedStream, {
+        elementType: 'MultimodalContent',
+        iteration: iteration,
+        interactionId: nextInteractionId,
+        session_id: sessionId,
+        transcript: '',
+        turn_detected: false,
+        stream_exhausted: isStreamExhausted,
+        interaction_complete: false,
+        error_occurred: true,
+        error_message: error instanceof Error ? error.message : String(error),
+        is_text_input: isTextInput,
+        text_content: textContent,
+      });
+    } finally {
+      if (session) {
+        session.offMessage(messageHandler);
+      }
+    }
+  }
+
+  private sendPartialTranscript(
+    sessionId: string,
+    interactionId: string,
+    text: string
+  ): void {
+    const connection = this.connections[sessionId];
+    if (!connection?.onPartialTranscript) {
+      return;
+    }
+
+    try {
+      connection.onPartialTranscript(text, interactionId);
+    } catch (error) {
+      console.error('[AssemblyAI] Error sending partial transcript:', error);
+    }
+  }
+
+  /**
+   * Close a specific session by sessionId
+   */
+  async closeSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      console.log(`[AssemblyAI] Closing session: ${sessionId}`);
+      await session.close();
+      this.sessions.delete(sessionId);
+    }
+  }
+
+  /**
+   * Clean up all resources
+   */
+  async destroy(): Promise<void> {
+    console.log(`[AssemblyAI] Destroying node: closing ${this.sessions.size} sessions`);
+
+    const promises: Promise<void>[] = [];
+    for (const session of this.sessions.values()) {
+      promises.push(session.close());
+    }
+
+    await Promise.all(promises);
+    this.sessions.clear();
+  }
+}
diff --git a/backend/components/graphs/nodes/dialog_prompt_builder_node.ts b/backend/components/graphs/nodes/dialog_prompt_builder_node.ts
new file mode 100644
index 0000000..73d05f7
--- /dev/null
+++ b/backend/components/graphs/nodes/dialog_prompt_builder_node.ts
@@ -0,0 +1,94 @@
+/**
+ * DialogPromptBuilderNode builds a LLM chat request from the state.
+ *
+ * This node is specifically designed for the language learning app and:
+ * - Receives the current conversation state
+ * - Applies the language-specific prompt template
+ * - Uses Jinja to render the prompt with conversation history and introduction state
+ * - Returns a formatted LLMChatRequest for the LLM node
+ */
+
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import { PromptBuilder } from '@inworld/runtime/primitives/llm';
+import { ConnectionsMap, State } from '../../../types/index.js';
+import { getLanguageConfig } from '../../../config/languages.js';
+import { conversationTemplate } from '../../../helpers/prompt-templates.js';
+
+export class DialogPromptBuilderNode extends CustomNode {
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    // connections passed for future use (e.g., accessing global state)
+  }
+
+  async process(
+    _context: ProcessContext,
+    state: State
+  ): Promise<GraphTypes.LLMChatRequest> {
+    console.log(
+      `[DialogPromptBuilder] Building prompt for ${state.languageCode || 'es'}, ${state.messages?.length || 0} messages`
+    );
+
+    // Get language config from state
+    const langConfig = getLanguageConfig(state.languageCode || 'es');
+
+    // Build template variables from language config
+    const templateVars = {
+      target_language: langConfig.name,
+      target_language_native: langConfig.nativeName,
+      teacher_name: langConfig.teacherPersona.name,
+      teacher_description: langConfig.teacherPersona.description,
+      example_topics: langConfig.exampleTopics.join(', '),
+      language_instructions: langConfig.promptInstructions,
+    };
+
+    // Get all messages except the last user message (that's our current_input)
+    const messages = state.messages || [];
+    const historyMessages = messages.slice(0, -1); // All except last
+    const lastMessage = messages[messages.length - 1];
+    const currentInput = lastMessage?.role === 'user' ? lastMessage.content : '';
+
+    // Get introduction state
+    const introductionState = state.introductionState || {
+      name: '',
+      level: '',
+      goal: '',
+      timestamp: '',
+    };
+
+    console.log('[DialogPromptBuilder] Introduction state:', JSON.stringify(introductionState));
+    console.log('[DialogPromptBuilder] Language:', langConfig.name);
+    console.log('[DialogPromptBuilder] Messages in history:', historyMessages.length);
+
+    const templateData = {
+      messages: historyMessages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      current_input: currentInput,
+      introduction_state: introductionState,
+      ...templateVars,
+    };
+
+    // Render the prompt using PromptBuilder (Jinja2)
+    const builder = await PromptBuilder.create(conversationTemplate);
+    const renderedPrompt = await builder.build(templateData);
+
+    // Debug: Log a snippet of the rendered prompt
+    const promptSnippet = renderedPrompt.substring(0, 400);
+    console.log(
+      `[DialogPromptBuilder] Rendered prompt (first 400 chars): ${promptSnippet}...`
+    );
+
+    // Return LLMChatRequest for the LLM node
+    return new GraphTypes.LLMChatRequest({
+      messages: [{ role: 'user', content: renderedPrompt }],
+    });
+  }
+}
diff --git a/backend/components/graphs/nodes/interaction_queue_node.ts b/backend/components/graphs/nodes/interaction_queue_node.ts
new file mode 100644
index 0000000..5c129ae
--- /dev/null
+++ b/backend/components/graphs/nodes/interaction_queue_node.ts
@@ -0,0 +1,167 @@
+/**
+ * InteractionQueueNode manages the queue of user interactions.
+ *
+ * This node:
+ * - Receives interaction info from STT processing
+ * - Manages a queue of interactions to ensure sequential processing
+ * - Prevents race conditions when multiple interactions arrive
+ * - Returns TextInput when ready to process, or empty when waiting
+ */
+
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../../types/index.js';
+
+export class InteractionQueueNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props?: {
+    id?: string;
+    connections?: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props?.id || 'interaction-queue-node',
+      reportToClient: props?.reportToClient,
+    });
+    this.connections = props?.connections || {};
+  }
+
+  process(
+    context: ProcessContext,
+    interactionInfo: InteractionInfo,
+    state: State
+  ): TextInput {
+    const sessionId = interactionInfo.sessionId;
+    console.log(
+      `[InteractionQueue] Processing interaction ${interactionInfo.interactionId}`
+    );
+
+    // Get current voiceId from connection state
+    const connection = this.connections[sessionId];
+    const currentVoiceId = connection?.state?.voiceId || state?.voiceId;
+
+    const dataStore = context.getDatastore();
+    const QUEUED_PREFIX = 'q';
+    const RUNNING_PREFIX = 'r';
+    const COMPLETED_PREFIX = 'c';
+
+    // Register interaction in the queue
+    if (!dataStore.has(QUEUED_PREFIX + interactionInfo.interactionId)) {
+      dataStore.add(
+        QUEUED_PREFIX + interactionInfo.interactionId,
+        interactionInfo.text
+      );
+      console.log(
+        `[InteractionQueue] New interaction queued: ${interactionInfo.interactionId}`
+      );
+    }
+
+    // Get all keys and categorize them
+    const allKeys = dataStore.keys();
+    const queuedIds: string[] = [];
+    let completedCount = 0;
+    let runningCount = 0;
+
+    for (const key of allKeys) {
+      if (key.startsWith(QUEUED_PREFIX)) {
+        const idStr = key.substring(QUEUED_PREFIX.length);
+        queuedIds.push(idStr);
+      } else if (key.startsWith(COMPLETED_PREFIX)) {
+        completedCount++;
+      } else if (key.startsWith(RUNNING_PREFIX)) {
+        runningCount++;
+      }
+    }
+
+    // Sort queued IDs by iteration number
+    queuedIds.sort((a, b) => {
+      const getIteration = (id: string): number => {
+        const hashIndex = id.indexOf('#');
+        if (hashIndex === -1) return 0;
+        const iter = parseInt(id.substring(hashIndex + 1), 10);
+        return isNaN(iter) ? 0 : iter;
+      };
+      return getIteration(a) - getIteration(b);
+    });
+
+    console.log(
+      `[InteractionQueue] State: queued=${queuedIds.length}, completed=${completedCount}, running=${runningCount}`
+    );
+
+    // Decide if we should start processing the next interaction
+    if (queuedIds.length === 0) {
+      console.log('[InteractionQueue] No interactions to process');
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      };
+    }
+
+    if (queuedIds.length === completedCount) {
+      console.log('[InteractionQueue] All interactions completed');
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      };
+    }
+
+    // There are unprocessed interactions
+    if (runningCount === completedCount) {
+      // No interaction is currently running, start the next one
+      const nextId = queuedIds[completedCount];
+      const runningKey = RUNNING_PREFIX + nextId;
+
+      // Try to mark as running
+      if (dataStore.has(runningKey) || !dataStore.add(runningKey, '')) {
+        console.log(
+          `[InteractionQueue] Interaction ${nextId} already started`
+        );
+        return {
+          text: '',
+          sessionId: sessionId,
+          interactionId: '',
+          voiceId: currentVoiceId,
+        };
+      }
+
+      const queuedText = dataStore.get(QUEUED_PREFIX + nextId) as string;
+      if (!queuedText) {
+        console.error(
+          `[InteractionQueue] Failed to retrieve text for ${nextId}`
+        );
+        return {
+          text: '',
+          sessionId: sessionId,
+          interactionId: '',
+          voiceId: currentVoiceId,
+        };
+      }
+
+      console.log(
+        `[InteractionQueue] Starting LLM processing: "${queuedText.substring(0, 50)}..."`
+      );
+
+      return {
+        text: queuedText,
+        sessionId: sessionId,
+        interactionId: nextId,
+        voiceId: currentVoiceId,
+      };
+    } else {
+      // An interaction is currently running, wait
+      console.log(
+        `[InteractionQueue] Waiting for interaction ${queuedIds[completedCount]}`
+      );
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      };
+    }
+  }
+}
diff --git a/backend/components/graphs/nodes/state_update_node.ts b/backend/components/graphs/nodes/state_update_node.ts
new file mode 100644
index 0000000..fb013c7
--- /dev/null
+++ b/backend/components/graphs/nodes/state_update_node.ts
@@ -0,0 +1,68 @@
+/**
+ * StateUpdateNode updates the state with the LLM's response.
+ *
+ * This node:
+ * - Receives the LLM output text
+ * - Updates the connection state with the assistant message
+ * - Marks the interaction as completed in the datastore
+ * - Returns the updated state
+ */
+
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { v4 as uuidv4 } from 'uuid';
+import { ConnectionsMap, State } from '../../../types/index.js';
+
+export class StateUpdateNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+  }
+
+  process(context: ProcessContext, llmOutput: string): State {
+    const sessionId = context.getDatastore().get('sessionId') as string;
+    console.log(
+      `[StateUpdateNode] Processing [length:${llmOutput?.length || 0}]`
+    );
+
+    const connection = this.connections[sessionId];
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId:${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId:${sessionId}`);
+    }
+
+    // Only add assistant message if there's actual content
+    if (llmOutput && llmOutput.trim().length > 0) {
+      console.log(
+        `[StateUpdateNode] Adding assistant message: "${llmOutput.substring(0, 50)}..."`
+      );
+      connection.state.messages.push({
+        role: 'assistant',
+        content: llmOutput,
+        id: connection.state.interactionId || uuidv4(),
+        timestamp: new Date().toISOString(),
+      });
+    } else {
+      console.log('[StateUpdateNode] Skipping empty message');
+    }
+
+    // Mark interaction as completed
+    const dataStore = context.getDatastore();
+    dataStore.add('c' + connection.state.interactionId, '');
+    console.log(
+      `[StateUpdateNode] Marked interaction ${connection.state.interactionId} as completed`
+    );
+
+    return connection.state;
+  }
+}
diff --git a/backend/components/graphs/nodes/text_input_node.ts b/backend/components/graphs/nodes/text_input_node.ts
new file mode 100644
index 0000000..ba3111d
--- /dev/null
+++ b/backend/components/graphs/nodes/text_input_node.ts
@@ -0,0 +1,61 @@
+/**
+ * TextInputNode updates the state with the user's input this turn.
+ *
+ * This node:
+ * - Receives user text input with interaction and session IDs
+ * - Updates the connection state with the user message
+ * - Returns the updated state for downstream processing
+ */
+
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { v4 as uuidv4 } from 'uuid';
+import { ConnectionsMap, State, TextInput } from '../../../types/index.js';
+
+export class TextInputNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+  }
+
+  process(_context: ProcessContext, input: TextInput): State {
+    console.log(
+      `[TextInputNode] Processing: "${input.text?.substring(0, 50)}..."`
+    );
+
+    const { text, interactionId, sessionId } = input;
+
+    const connection = this.connections[sessionId];
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId:${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId:${sessionId}`);
+    }
+    const state = connection.state;
+    if (!state) {
+      throw Error(`Failed to read state from connection for sessionId:${sessionId}`);
+    }
+
+    // Update interactionId
+    connection.state.interactionId = interactionId;
+
+    // Add user message to conversation
+    connection.state.messages.push({
+      role: 'user',
+      content: text,
+      id: interactionId || uuidv4(),
+      timestamp: new Date().toISOString(),
+    });
+
+    return connection.state;
+  }
+}
diff --git a/backend/components/graphs/nodes/transcript_extractor_node.ts b/backend/components/graphs/nodes/transcript_extractor_node.ts
new file mode 100644
index 0000000..c4b33d4
--- /dev/null
+++ b/backend/components/graphs/nodes/transcript_extractor_node.ts
@@ -0,0 +1,51 @@
+/**
+ * TranscriptExtractorNode extracts transcript information from
+ * DataStreamWithMetadata (output from AssemblyAISTTNode) and converts
+ * it to InteractionInfo for downstream processing.
+ */
+
+import { DataStreamWithMetadata } from '@inworld/runtime';
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { InteractionInfo } from '../../../types/index.js';
+
+export class TranscriptExtractorNode extends CustomNode {
+  constructor(props?: { id?: string; reportToClient?: boolean }) {
+    super({
+      id: props?.id || 'transcript-extractor-node',
+      reportToClient: props?.reportToClient,
+    });
+  }
+
+  /**
+   * Extract transcript from metadata and return as InteractionInfo
+   */
+  process(
+    context: ProcessContext,
+    streamWithMetadata: DataStreamWithMetadata
+  ): InteractionInfo {
+    const metadata = streamWithMetadata.getMetadata();
+    const sessionId = context.getDatastore().get('sessionId') as string;
+
+    // Extract transcript and related info from metadata
+    const transcript = (metadata.transcript as string) || '';
+    const interactionComplete =
+      (metadata.interaction_complete as boolean) || false;
+    const iteration = (metadata.iteration as number) || 1;
+    const interactionId = String(metadata.interactionId || iteration);
+
+    console.log(
+      `[TranscriptExtractor] Processing [iteration:${iteration}]: "${transcript?.substring(0, 50)}..." [complete:${interactionComplete}]`
+    );
+
+    return {
+      sessionId,
+      interactionId: interactionId,
+      text: transcript,
+      interactionComplete,
+    };
+  }
+
+  async destroy(): Promise<void> {
+    // No cleanup needed
+  }
+}
diff --git a/backend/components/graphs/nodes/tts_request_builder_node.ts b/backend/components/graphs/nodes/tts_request_builder_node.ts
new file mode 100644
index 0000000..1af2ca8
--- /dev/null
+++ b/backend/components/graphs/nodes/tts_request_builder_node.ts
@@ -0,0 +1,64 @@
+/**
+ * TTSRequestBuilderNode builds a TTSRequest with dynamic voiceId.
+ *
+ * For long-running graphs, it reads voiceId from connection state at processing time
+ * to ensure voice changes via language switching are reflected immediately.
+ */
+
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import { ConnectionsMap } from '../../../types/index.js';
+import { getLanguageConfig } from '../../../config/languages.js';
+
+export class TTSRequestBuilderNode extends CustomNode {
+  private connections: ConnectionsMap;
+  private defaultVoiceId: string;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    defaultVoiceId: string;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+    this.defaultVoiceId = props.defaultVoiceId;
+  }
+
+  /**
+   * Build a TTSRequest with the current voiceId from connection state
+   * Receives two inputs:
+   * 1. input - Graph input with sessionId (TextInput or State)
+   * 2. textStream - The text stream from TextChunkingNode
+   */
+  process(
+    context: ProcessContext,
+    _input: unknown,
+    textStream: GraphTypes.TextStream
+  ): GraphTypes.TTSRequest {
+    const sessionId = context.getDatastore().get('sessionId') as string;
+
+    // For long-running graphs, read voiceId from connection state at processing time
+    const connection = this.connections[sessionId];
+
+    // Get voice from state, or fall back to language config, or default
+    let voiceId = connection?.state?.voiceId;
+    if (!voiceId && connection?.state?.languageCode) {
+      const langConfig = getLanguageConfig(connection.state.languageCode);
+      voiceId = langConfig.ttsConfig.speakerId;
+    }
+    voiceId = voiceId || this.defaultVoiceId;
+
+    console.log(`[TTSRequestBuilder] Building TTS request [voice:${voiceId}]`);
+
+    return GraphTypes.TTSRequest.withStream(textStream, {
+      id: voiceId,
+    });
+  }
+
+  async destroy(): Promise<void> {
+    // No cleanup needed
+  }
+}
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
deleted file mode 100644
index 14afe67..0000000
--- a/backend/graphs/conversation-graph.ts
+++ /dev/null
@@ -1,267 +0,0 @@
-import {
-  GraphBuilder,
-  CustomNode,
-  ProcessContext,
-  ProxyNode,
-  RemoteLLMChatNode,
-  RemoteSTTNode,
-  RemoteTTSNode,
-  TextChunkingNode,
-  Graph,
-} from '@inworld/runtime/graph';
-import { GraphTypes } from '@inworld/runtime/common';
-import { renderJinja } from '@inworld/runtime/primitives/llm';
-import { AsyncLocalStorage } from 'async_hooks';
-import { conversationTemplate } from '../helpers/prompt-templates.js';
-import type { IntroductionState } from '../helpers/introduction-state-processor.js';
-import {
-  LanguageConfig,
-  getLanguageConfig,
-  DEFAULT_LANGUAGE_CODE,
-} from '../config/languages.js';
-
-export interface ConversationGraphConfig {
-  apiKey: string;
-}
-
-// Use AsyncLocalStorage to store state accessors directly per async execution context
-// This eliminates the need for a registry and connectionId lookup
-export const stateStorage = new AsyncLocalStorage<{
-  getConversationState: () => {
-    messages: Array<{ role: string; content: string; timestamp: string }>;
-  };
-  getIntroductionState: () => IntroductionState;
-  getLanguageConfig: () => LanguageConfig;
-}>();
-
-// Store the current execution context as module-level variables
-// This is set by AudioProcessor before starting graph execution
-// and read by the PromptBuilder during execution.
-// This works because Node.js is single-threaded for synchronous execution.
-let currentExecutionLanguageCode: string = DEFAULT_LANGUAGE_CODE;
-let currentGetConversationState: (() => { messages: Array<{ role: string; content: string; timestamp: string }> }) | null = null;
-let currentGetIntroductionState: (() => IntroductionState) | null = null;
-
-/**
- * Set the execution context for the current graph execution.
- * Must be called before starting graph execution.
- */
-export function setCurrentExecutionContext(context: {
-  languageCode: string;
-  getConversationState: () => { messages: Array<{ role: string; content: string; timestamp: string }> };
-  getIntroductionState: () => IntroductionState;
-}): void {
-  currentExecutionLanguageCode = context.languageCode;
-  currentGetConversationState = context.getConversationState;
-  currentGetIntroductionState = context.getIntroductionState;
-  console.log(`[ConversationGraph] Set execution context for language: ${context.languageCode}`);
-}
-
-/**
- * Set the language code for the current graph execution.
- * @deprecated Use setCurrentExecutionContext instead
- */
-export function setCurrentExecutionLanguage(languageCode: string): void {
-  currentExecutionLanguageCode = languageCode;
-  console.log(`[ConversationGraph] Set execution language to: ${languageCode}`);
-}
-
-/**
- * EnhancedPromptBuilderNode - defined once at module level to avoid
- * component registry collisions. State and language config are retrieved from
- * module-level variables (set by AudioProcessor before graph execution).
- */
-class EnhancedPromptBuilderNode extends CustomNode {
-  async process(_context: ProcessContext, currentInput: string) {
-    // Get language config using the current execution language code
-    const langConfig = getLanguageConfig(currentExecutionLanguageCode);
-    const nodeId = (this as unknown as { id: string }).id;
-
-    console.log(
-      `[PromptBuilder] Node ${nodeId} using execution language: ${langConfig.name} (code: ${currentExecutionLanguageCode})`
-    );
-
-    // Build template variables from language config
-    const templateVars = {
-      target_language: langConfig.name,
-      target_language_native: langConfig.nativeName,
-      teacher_name: langConfig.teacherPersona.name,
-      teacher_description: langConfig.teacherPersona.description,
-      example_topics: langConfig.exampleTopics.join(', '),
-      language_instructions: langConfig.promptInstructions,
-    };
-
-    // Get state from module-level accessors (set by AudioProcessor before execution)
-    // These bypass AsyncLocalStorage which gets broken by Inworld runtime
-    const conversationState = currentGetConversationState
-      ? currentGetConversationState()
-      : { messages: [] };
-    const introductionState = currentGetIntroductionState
-      ? currentGetIntroductionState()
-      : { name: '', level: '', goal: '', timestamp: '' };
-
-    console.log(
-      '[PromptBuilder] Introduction state:',
-      JSON.stringify(introductionState, null, 2)
-    );
-    console.log('[PromptBuilder] Language:', langConfig.name);
-    console.log(
-      '[PromptBuilder] Messages in history:',
-      conversationState.messages?.length || 0
-    );
-
-    const templateData = {
-      messages: conversationState.messages || [],
-      current_input: currentInput,
-      introduction_state: introductionState,
-      ...templateVars,
-    };
-
-    const renderedPrompt = await renderJinja(
-      conversationTemplate,
-      JSON.stringify(templateData)
-    );
-
-    // Debug: Log a snippet of the rendered prompt to verify content
-    const promptSnippet = renderedPrompt.substring(0, 400);
-    console.log(
-      `[PromptBuilder] Rendered prompt (first 400 chars): ${promptSnippet}...`
-    );
-
-    // Return LLMChatRequest for the LLM node
-    return new GraphTypes.LLMChatRequest({
-      messages: [{ role: 'user', content: renderedPrompt }],
-    });
-  }
-}
-
-/**
- * Creates a conversation graph configured for a specific language
- */
-function createConversationGraphForLanguage(
-  _config: ConversationGraphConfig,
-  languageConfig: LanguageConfig
-): Graph {
-
-  // Use language code as suffix to make node IDs unique per language
-  // This prevents edge condition name collisions in the global callback registry
-  const langSuffix = `_${languageConfig.code}`;
-  const promptBuilderNodeId = `enhanced_prompt_builder_node${langSuffix}`;
-
-  console.log(
-    `[ConversationGraph] Creating graph with prompt builder node: ${promptBuilderNodeId}`
-  );
-
-  // Configure STT for the specific language
-  const sttNode = new RemoteSTTNode({
-    id: `stt_node${langSuffix}`,
-    sttConfig: {
-      languageCode: languageConfig.sttLanguageCode,
-    },
-  });
-
-  const sttOutputNode = new ProxyNode({
-    id: `proxy_node${langSuffix}`,
-    reportToClient: true,
-  });
-
-  const promptBuilderNode = new EnhancedPromptBuilderNode({
-    id: promptBuilderNodeId,
-  });
-
-  const llmNode = new RemoteLLMChatNode({
-    id: `llm_node${langSuffix}`,
-    provider: 'openai',
-    modelName: 'gpt-4o-mini',
-    stream: true,
-    reportToClient: true,
-    textGenerationConfig: {
-      maxNewTokens: 250,
-      maxPromptLength: 2000,
-      repetitionPenalty: 1,
-      topP: 1,
-      temperature: 1,
-      frequencyPenalty: 0,
-      presencePenalty: 0,
-    },
-  });
-
-  const chunkerNode = new TextChunkingNode({ id: `chunker_node${langSuffix}` });
-
-  // Configure TTS for the specific language
-  const ttsNode = new RemoteTTSNode({
-    id: `tts_node${langSuffix}`,
-    speakerId: languageConfig.ttsConfig.speakerId,
-    modelId: languageConfig.ttsConfig.modelId,
-    sampleRate: 16000,
-    speakingRate: languageConfig.ttsConfig.speakingRate,
-    temperature: languageConfig.ttsConfig.temperature,
-    languageCode: languageConfig.ttsConfig.languageCode,
-  });
-
-  const executor = new GraphBuilder({
-    id: `conversation_graph_${languageConfig.code}`,
-    enableRemoteConfig: false,
-  })
-    .addNode(sttNode)
-    .addNode(sttOutputNode)
-    .addNode(promptBuilderNode)
-    .addNode(llmNode)
-    .addNode(chunkerNode)
-    .addNode(ttsNode)
-    .setStartNode(sttNode)
-    .addEdge(sttNode, sttOutputNode)
-    .addEdge(sttNode, promptBuilderNode, {
-      condition: async (input: string) => {
-        return input.trim().length > 0;
-      },
-    })
-    .addEdge(promptBuilderNode, llmNode)
-    .addEdge(llmNode, chunkerNode)
-    .addEdge(chunkerNode, ttsNode)
-    .setEndNode(sttOutputNode)
-    .setEndNode(ttsNode)
-    .build();
-
-  return executor;
-}
-
-// Cache for language-specific graphs
-const graphCache = new Map<string, Graph>();
-
-/**
- * Get or create a conversation graph for a specific language
- * Graphs are cached to avoid recreation overhead
- */
-export function getConversationGraph(
-  config: ConversationGraphConfig,
-  languageCode: string = DEFAULT_LANGUAGE_CODE
-): Graph {
-  const cacheKey = languageCode;
-
-  if (!graphCache.has(cacheKey)) {
-    const languageConfig = getLanguageConfig(languageCode);
-    console.log(
-      `Creating conversation graph for language: ${languageConfig.name} (${languageCode})`
-    );
-    const graph = createConversationGraphForLanguage(config, languageConfig);
-    graphCache.set(cacheKey, graph);
-  }
-
-  return graphCache.get(cacheKey)!;
-}
-
-/**
- * Legacy function for backwards compatibility
- * Creates or returns the default (Spanish) graph
- */
-export function createConversationGraph(config: ConversationGraphConfig): Graph {
-  return getConversationGraph(config, DEFAULT_LANGUAGE_CODE);
-}
-
-/**
- * Clear the graph cache (useful for testing or reconfiguration)
- */
-export function clearGraphCache(): void {
-  graphCache.clear();
-}
diff --git a/backend/graphs/flashcard-graph.ts b/backend/graphs/flashcard-graph.ts
index 3990d7e..b9b87e0 100644
--- a/backend/graphs/flashcard-graph.ts
+++ b/backend/graphs/flashcard-graph.ts
@@ -1,5 +1,4 @@
 import 'dotenv/config';
-import fs from 'fs';
 
 import {
   GraphBuilder,
@@ -9,7 +8,7 @@ import {
   Graph,
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
-import { renderJinja } from '@inworld/runtime/primitives/llm';
+import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { flashcardPromptTemplate } from '../helpers/prompt-templates.js';
 import { v4 } from 'uuid';
 import { Flashcard } from '../helpers/flashcard-processor.js';
@@ -24,10 +23,8 @@ class FlashcardPromptBuilderNode extends CustomNode {
     _context: ProcessContext,
     input: GraphTypes.Content | Record<string, unknown>
   ) {
-    const renderedPrompt = await renderJinja(
-      flashcardPromptTemplate,
-      JSON.stringify(input)
-    );
+    const builder = await PromptBuilder.create(flashcardPromptTemplate);
+    const renderedPrompt = await builder.build(input as Record<string, unknown>);
     return renderedPrompt;
   }
 }
@@ -99,7 +96,7 @@ function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph
   const llmNode = new RemoteLLMChatNode({
     id: 'llm_node',
     provider: 'openai',
-    modelName: 'gpt-5',
+    modelName: 'gpt-4o-mini',
     stream: false,
     textGenerationConfig: {
       maxNewTokens: 2500,
@@ -115,7 +112,7 @@ function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph
 
   const executor = new GraphBuilder({
     id: `flashcard-generation-graph-${languageConfig.code}`,
-    enableRemoteConfig: true,
+    enableRemoteConfig: false,
   })
     .addNode(promptBuilderNode)
     .addNode(textToChatRequestNode)
@@ -128,11 +125,6 @@ function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph
     .setEndNode(parserNode)
     .build();
 
-  // Only write debug file for default language to avoid cluttering
-  if (languageConfig.code === DEFAULT_LANGUAGE_CODE) {
-    fs.writeFileSync('flashcard-graph.json', executor.toJSON());
-  }
-
   return executor;
 }
 
diff --git a/backend/graphs/introduction-state-graph.ts b/backend/graphs/introduction-state-graph.ts
index fb929a9..bc1e817 100644
--- a/backend/graphs/introduction-state-graph.ts
+++ b/backend/graphs/introduction-state-graph.ts
@@ -7,7 +7,7 @@ import {
   Graph,
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
-import { renderJinja } from '@inworld/runtime/primitives/llm';
+import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { introductionStatePromptTemplate } from '../helpers/prompt-templates.js';
 import {
   LanguageConfig,
@@ -29,10 +29,8 @@ class IntroductionPromptBuilderNode extends CustomNode {
     _context: ProcessContext,
     input: GraphTypes.Content | Record<string, unknown>
   ) {
-    const renderedPrompt = await renderJinja(
-      introductionStatePromptTemplate,
-      JSON.stringify(input)
-    );
+    const builder = await PromptBuilder.create(introductionStatePromptTemplate);
+    const renderedPrompt = await builder.build(input as Record<string, unknown>);
     return renderedPrompt;
   }
 }
@@ -163,7 +161,7 @@ function createIntroductionStateGraphForLanguage(
   const llmNode = new RemoteLLMChatNode({
     id: 'llm_node',
     provider: 'openai',
-    modelName: 'gpt-4.1',
+    modelName: 'gpt-4o-mini',
     stream: false,
   });
   const parserNode = new IntroductionStateParserNode({
@@ -172,6 +170,7 @@ function createIntroductionStateGraphForLanguage(
 
   const executor = new GraphBuilder({
     id: `introduction-state-graph-${languageConfig.code}`,
+    enableRemoteConfig: false,
   })
     .addNode(promptBuilderNode)
     .addNode(textToChatRequestNode)
diff --git a/backend/helpers/audio-processor.ts b/backend/helpers/audio-processor.ts
deleted file mode 100644
index 1a122c7..0000000
--- a/backend/helpers/audio-processor.ts
+++ /dev/null
@@ -1,790 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { GraphTypes } from '@inworld/runtime/common';
-import { UserContextInterface } from '@inworld/runtime/graph';
-import { Graph } from '@inworld/runtime/graph';
-import { WebSocket } from 'ws';
-import { SileroVAD, VADConfig } from './silero-vad.js';
-import { stateStorage, setCurrentExecutionContext } from '../graphs/conversation-graph.js';
-import type { IntroductionState } from './introduction-state-processor.js';
-import {
-  LanguageConfig,
-  getLanguageConfig,
-  DEFAULT_LANGUAGE_CODE,
-} from '../config/languages.js';
-
-export class AudioProcessor {
-  private executor: Graph;
-  private vad: SileroVAD | null = null;
-  private isProcessing = false;
-  private isProcessingCancelled = false; // Track if current processing should be cancelled
-  private isReady = false;
-  private websocket: WebSocket | null = null;
-  private pendingSpeechSegments: Float32Array[] = []; // Accumulate speech segments
-  private conversationState: {
-    messages: Array<{ role: string; content: string; timestamp: string }>;
-  } = {
-    messages: [],
-  };
-  private flashcardCallback:
-    | ((messages: Array<{ role: string; content: string }>) => Promise<void>)
-    | null = null;
-  private introductionState: IntroductionState = {
-    name: '',
-    level: '',
-    goal: '',
-    timestamp: '',
-  };
-  private introductionStateCallback:
-    | ((
-        messages: Array<{ role: string; content: string }>
-      ) => Promise<IntroductionState | null>)
-    | null = null;
-  private targetingKey: string | null = null;
-  private clientTimezone: string | null = null;
-  private graphStartTime: number = 0;
-  private languageCode: string = DEFAULT_LANGUAGE_CODE;
-  private languageConfig: LanguageConfig;
-
-  constructor(
-    executor: Graph,
-    websocket?: WebSocket,
-    languageCode: string = DEFAULT_LANGUAGE_CODE
-  ) {
-    this.executor = executor;
-    this.websocket = websocket ?? null;
-    this.languageCode = languageCode;
-    this.languageConfig = getLanguageConfig(languageCode);
-    this.setupWebSocketMessageHandler();
-    setTimeout(() => this.initialize(), 100);
-  }
-
-  /**
-   * Update the language and graph for this processor
-   */
-  setLanguage(languageCode: string, newGraph: Graph): void {
-    if (this.languageCode !== languageCode) {
-      console.log(
-        `AudioProcessor: Changing language from ${this.languageCode} to ${languageCode}`
-      );
-      this.languageCode = languageCode;
-      this.languageConfig = getLanguageConfig(languageCode);
-      this.executor = newGraph;
-
-      // Reset conversation state when language changes
-      this.reset();
-
-      console.log(
-        `AudioProcessor: Language changed to ${this.languageConfig.name}`
-      );
-    }
-  }
-
-  /**
-   * Get current language code
-   */
-  getLanguageCode(): string {
-    return this.languageCode;
-  }
-
-  /**
-   * Get current language config
-   */
-  getLanguageConfig(): LanguageConfig {
-    return this.languageConfig;
-  }
-
-  // Public methods for state registry access
-  getConversationState() {
-    return this.conversationState;
-  }
-
-  getIntroductionState(): IntroductionState {
-    return this.introductionState;
-  }
-
-  private trimConversationHistory(maxTurns: number = 40) {
-    const maxMessages = maxTurns * 2;
-    if (this.conversationState.messages.length > maxMessages) {
-      this.conversationState.messages =
-        this.conversationState.messages.slice(-maxMessages);
-    }
-  }
-
-  private setupWebSocketMessageHandler() {
-    if (this.websocket) {
-      this.websocket.on('message', (data: Buffer | string) => {
-        try {
-          const raw =
-            typeof data === 'string' ? data : data?.toString?.() || '';
-          const message = JSON.parse(raw);
-
-          if (message.type === 'conversation_update') {
-            const incoming =
-              message.data && message.data.messages
-                ? message.data.messages
-                : [];
-            const existing = this.conversationState.messages || [];
-            const combined = [...existing, ...incoming];
-            const seen = new Set<string>();
-            const deduped: Array<{
-              role: string;
-              content: string;
-              timestamp: string;
-            }> = [];
-            for (const m of combined) {
-              const key = `${m.timestamp}|${m.role}|${m.content}`;
-              if (!seen.has(key)) {
-                seen.add(key);
-                deduped.push(m);
-              }
-            }
-            deduped.sort(
-              (a, b) =>
-                new Date(a.timestamp).getTime() -
-                new Date(b.timestamp).getTime()
-            );
-            this.conversationState = { messages: deduped };
-            this.trimConversationHistory(40);
-          } else if (message.type === 'user_context') {
-            // Persist minimal attributes for user context
-            const tz =
-              message.timezone || (message.data && message.data.timezone) || '';
-            const uid =
-              message.userId || (message.data && message.data.userId) || '';
-            this.clientTimezone = tz || this.clientTimezone;
-            if (uid) this.targetingKey = uid;
-          }
-        } catch {
-          // Not a JSON message or conversation update, ignore
-        }
-      });
-    }
-  }
-
-  setFlashcardCallback(
-    callback: (
-      messages: Array<{ role: string; content: string }>
-    ) => Promise<void>
-  ) {
-    this.flashcardCallback = callback;
-  }
-
-  setIntroductionStateCallback(
-    callback: (
-      messages: Array<{ role: string; content: string }>
-    ) => Promise<IntroductionState | null>
-  ) {
-    this.introductionStateCallback = callback;
-  }
-
-  private async initialize() {
-    try {
-      console.log('AudioProcessor: Starting initialization...');
-
-      // Initialize VAD
-      try {
-        const vadConfig: VADConfig = {
-          modelPath: 'backend/models/silero_vad.onnx',
-          threshold: 0.5, // Following working example SPEECH_THRESHOLD
-          minSpeechDuration: 0.2, // MIN_SPEECH_DURATION_MS / 1000
-          minSilenceDuration: 0.4, // Reduced from 0.65 for faster response
-          speechResetSilenceDuration: 1.0,
-          minVolume: 0.01, // Lower threshold to start - can adjust based on testing
-          sampleRate: 16000,
-        };
-
-        console.log(
-          'AudioProcessor: Creating SileroVAD with config:',
-          vadConfig
-        );
-        this.vad = new SileroVAD(vadConfig);
-
-        console.log('AudioProcessor: Initializing VAD...');
-        await this.vad.initialize();
-        console.log('AudioProcessor: VAD initialized successfully');
-
-        this.vad.on('speechStart', () => {
-          console.log('🎤 Speech started');
-
-          // Always notify frontend to stop audio playback when user starts speaking
-          if (this.websocket) {
-            try {
-              this.websocket.send(
-                JSON.stringify({ type: 'interrupt', reason: 'speech_start' })
-              );
-              // Notify frontend that speech was detected so it can show listening indicator
-              this.websocket.send(
-                JSON.stringify({
-                  type: 'speech_detected',
-                  data: { text: '' }, // Empty text initially, will be updated with transcript
-                })
-              );
-            } catch {
-              // ignore send errors
-            }
-          }
-
-          // If we're currently processing, set cancellation flag
-          if (this.isProcessing) {
-            console.log(
-              'Setting cancellation flag - user started speaking during processing'
-            );
-            this.isProcessingCancelled = true;
-            // Don't clear segments - we want to accumulate them
-          }
-        });
-
-        this.vad.on('speechEnd', async (event) => {
-          console.log(
-            '🔇 Speech ended, duration:',
-            event.speechDuration.toFixed(2) + 's'
-          );
-
-          // Always notify frontend that VAD stopped detecting speech
-          // This allows frontend to clear the real-time transcript bubble
-          if (this.websocket) {
-            try {
-              this.websocket.send(
-                JSON.stringify({
-                  type: 'speech_ended',
-                  data: {
-                    speechDuration: event.speechDuration,
-                    hasSegment:
-                      event.speechSegment !== null &&
-                      event.speechSegment.length > 0,
-                  },
-                })
-              );
-            } catch {
-              // ignore send errors
-            }
-          }
-
-          try {
-            if (event.speechSegment && event.speechSegment.length > 0) {
-              // Add this segment to pending segments
-              this.pendingSpeechSegments.push(event.speechSegment);
-
-              // Reset cancellation flag for new processing
-              this.isProcessingCancelled = false;
-
-              // Process immediately if not already processing
-              if (!this.isProcessing && this.pendingSpeechSegments.length > 0) {
-                // Combine all pending segments
-                const totalLength = this.pendingSpeechSegments.reduce(
-                  (sum, seg) => sum + seg.length,
-                  0
-                );
-                const combinedSegment = new Float32Array(totalLength);
-                let offset = 0;
-                for (const seg of this.pendingSpeechSegments) {
-                  combinedSegment.set(seg, offset);
-                  offset += seg.length;
-                }
-
-                // Clear pending segments
-                this.pendingSpeechSegments = [];
-
-                // Process immediately
-                console.log('Processing speech segment immediately');
-                await this.processVADSpeechSegment(combinedSegment);
-              }
-            }
-          } catch (error) {
-            console.error('Error handling speech segment:', error);
-          }
-        });
-      } catch (error) {
-        console.error('AudioProcessor: VAD initialization failed:', error);
-        this.vad = null;
-      }
-
-      // Graph is already provided in constructor (shared instance)
-      // Just mark as ready
-      this.isReady = true;
-      console.log(
-        `AudioProcessor: Using ${this.languageConfig.name} conversation graph, ready for audio processing`
-      );
-    } catch (error) {
-      console.error(
-        'AudioProcessor: Initialization failed with unexpected error:',
-        error
-      );
-      this.isReady = false;
-      // Don't rethrow - prevent unhandled promise rejection
-    }
-  }
-
-  addAudioChunk(base64Audio: string) {
-    try {
-      // Feed audio to VAD if available and ready
-      if (this.vad && this.isReady) {
-        this.vad.addAudioData(base64Audio);
-      } else {
-        // VAD not available - log error and ignore audio chunk
-        if (!this.vad) {
-          console.error('VAD not available - cannot process audio chunk');
-        } else if (!this.isReady) {
-          console.warn('AudioProcessor not ready yet - ignoring audio chunk');
-        }
-      }
-    } catch (error) {
-      console.error('Error processing audio chunk:', error);
-    }
-  }
-
-  private amplifyAudio(audioData: Float32Array, gain: number): Float32Array {
-    const amplified = new Float32Array(audioData.length);
-
-    let maxVal = 0;
-    for (let i = 0; i < audioData.length; i++) {
-      const absVal = Math.abs(audioData[i]);
-      if (absVal > maxVal) {
-        maxVal = absVal;
-      }
-    }
-
-    // For normalized Float32 audio [-1, 1], prevent clipping at 1.0
-    const safeGain = maxVal > 0 ? Math.min(gain, 0.95 / maxVal) : gain;
-
-    for (let i = 0; i < audioData.length; i++) {
-      // Clamp to [-1, 1] range to prevent distortion
-      amplified[i] = Math.max(-1, Math.min(1, audioData[i] * safeGain));
-    }
-
-    return amplified;
-  }
-
-  private async processVADSpeechSegment(
-    speechSegment: Float32Array
-  ): Promise<void> {
-    if (this.isProcessing) {
-      return;
-    }
-
-    this.isProcessing = true;
-
-    try {
-      const amplifiedSegment = this.amplifyAudio(speechSegment, 2.0);
-
-      // Save debug audio before sending to STT
-      // await this.saveAudioDebug(amplifiedSegment, 'vad-segment');
-
-      // Create Audio instance for STT node
-      const audioInput = new GraphTypes.Audio({
-        data: Array.from(amplifiedSegment),
-        sampleRate: 16000,
-      });
-
-      // Build user context for experiments
-      const attributes: Record<string, string> = {
-        timezone: this.clientTimezone || '',
-        language: this.languageCode,
-      };
-      attributes.name =
-        (this.introductionState?.name && this.introductionState.name.trim()) ||
-        'unknown';
-      attributes.level =
-        (this.introductionState?.level &&
-          (this.introductionState.level as string)) ||
-        'unknown';
-      attributes.goal =
-        (this.introductionState?.goal && this.introductionState.goal.trim()) ||
-        'unknown';
-
-      const targetingKey = this.targetingKey || uuidv4();
-      const userContext: UserContextInterface = {
-        attributes: attributes,
-        targetingKey: targetingKey,
-      };
-      console.log(userContext);
-
-      this.graphStartTime = Date.now();
-
-      // Set the current execution context BEFORE starting the graph
-      // This ensures the PromptBuilder node has access to state and language config
-      // We use module-level variables because Inworld runtime breaks AsyncLocalStorage context
-      setCurrentExecutionContext({
-        languageCode: this.languageCode,
-        getConversationState: () => this.getConversationState(),
-        getIntroductionState: () => this.getIntroductionState(),
-      });
-
-      // Also use AsyncLocalStorage as a fallback (may work in some contexts)
-      const executionResult = await stateStorage.run(
-        {
-          getConversationState: () => this.getConversationState(),
-          getIntroductionState: () => this.getIntroductionState(),
-          getLanguageConfig: () => this.getLanguageConfig(),
-        },
-        async () => {
-          try {
-            const executionContext = {
-              executionId: uuidv4(),
-              userContext: userContext,
-            };
-            return await this.executor.start(audioInput, executionContext);
-          } catch (err) {
-            console.warn(
-              'Executor.start with ExecutionContext failed, falling back without context:',
-              err
-            );
-            return await this.executor.start(audioInput);
-          }
-        }
-      );
-
-      let transcription = '';
-      let llmResponse = '';
-
-      for await (const chunk of executionResult.outputStream) {
-        // Check if processing has been cancelled
-        if (this.isProcessingCancelled) {
-          console.log(
-            'Processing cancelled by user speech, breaking from loop'
-          );
-          break;
-        }
-
-        console.log(
-          `Audio Processor:Chunk received - Type: ${chunk.typeName}, Has processResponse: ${typeof chunk.processResponse === 'function'}`
-        );
-        console.log(
-          `Audio Processor:Time since graph started: ${Date.now() - this.graphStartTime}ms`
-        );
-
-        // Use processResponse for type-safe handling
-        await chunk.processResponse({
-          // Handle string output (from ProxyNode with STT transcription)
-          string: (data: string) => {
-            transcription = data;
-
-            // Debug: always log raw STT result for troubleshooting
-            console.log(
-              `VAD STT Raw Result [${this.languageCode}]: "${data}" (length: ${data.length}, trimmed: ${data.trim().length})`
-            );
-
-            if (transcription.trim() === '') {
-              console.log(
-                `VAD STT: Empty transcription for ${this.languageCode}, skipping LLM`
-              );
-              return;
-            }
-
-            console.log(
-              `VAD STT Transcription (via ProxyNode): "${transcription}"`
-            );
-
-            if (this.websocket) {
-              this.websocket.send(
-                JSON.stringify({
-                  type: 'transcription',
-                  text: transcription.trim(),
-                  timestamp: Date.now(),
-                })
-              );
-            }
-            // Don't add to conversation state yet - the prompt template will use it as current_input
-            // We'll add it after processing completes
-
-            // Opportunistically run introduction-state extraction as soon as we have user input
-            const isIntroCompleteEarly = Boolean(
-              this.introductionState?.name &&
-                this.introductionState?.level &&
-                this.introductionState?.goal
-            );
-            if (!isIntroCompleteEarly && this.introductionStateCallback) {
-              const recentMessages = this.conversationState.messages
-                .slice(-6)
-                .map((msg) => ({
-                  role: msg.role,
-                  content: msg.content,
-                }));
-              this.introductionStateCallback(recentMessages)
-                .then((state) => {
-                  if (state) {
-                    this.introductionState = state;
-                    if (this.websocket) {
-                      this.websocket.send(
-                        JSON.stringify({
-                          type: 'introduction_state_updated',
-                          introduction_state: this.introductionState,
-                          timestamp: Date.now(),
-                        })
-                      );
-                    }
-                  }
-                })
-                .catch((error) => {
-                  console.error(
-                    'Error in introduction-state callback (early):',
-                    error
-                  );
-                });
-            }
-          },
-
-          // Handle ContentStream (from LLM)
-          ContentStream: async (streamIterator: GraphTypes.ContentStream) => {
-            console.log('VAD Processing LLM ContentStream...');
-            let currentLLMResponse = '';
-            for await (const streamChunk of streamIterator) {
-              if (streamChunk.text) {
-                currentLLMResponse += streamChunk.text;
-                // console.log('VAD LLM chunk:', streamChunk.text);
-                if (this.websocket) {
-                  this.websocket.send(
-                    JSON.stringify({
-                      type: 'llm_response_chunk',
-                      text: streamChunk.text,
-                      timestamp: Date.now(),
-                    })
-                  );
-                }
-              }
-            }
-            if (currentLLMResponse.trim()) {
-              llmResponse = currentLLMResponse;
-              console.log(`VAD Complete LLM Response: "${llmResponse}"`);
-              if (this.websocket) {
-                this.websocket.send(
-                  JSON.stringify({
-                    type: 'llm_response_complete',
-                    text: llmResponse.trim(),
-                    timestamp: Date.now(),
-                  })
-                );
-              }
-              // Now update conversation state with both user and assistant messages
-              // Add user message first (it wasn't added earlier to avoid duplication)
-              this.conversationState.messages.push({
-                role: 'user',
-                content: transcription.trim(),
-                timestamp: new Date().toISOString(),
-              });
-              // Then add assistant message
-              this.conversationState.messages.push({
-                role: 'assistant',
-                content: llmResponse.trim(),
-                timestamp: new Date().toISOString(),
-              });
-              this.trimConversationHistory(40);
-              console.log('Updated conversation state with full exchange');
-
-              // Mark that we'll need to trigger flashcard generation after TTS completes
-              // We'll do this after all TTS chunks have been sent
-            }
-          },
-
-          // Handle TTS output stream
-          TTSOutputStream: async (
-            ttsStreamIterator: GraphTypes.TTSOutputStream
-          ) => {
-            console.log('VAD Processing TTS audio stream...');
-            let isFirstChunk = true;
-            for await (const ttsChunk of ttsStreamIterator) {
-              if (ttsChunk.audio && ttsChunk.audio.data) {
-                // Log first chunk for latency tracking
-                if (isFirstChunk) {
-                  console.log('Sending first TTS chunk immediately');
-                }
-
-                // Decode base64 and create Float32Array
-                const decodedData = Buffer.from(ttsChunk.audio.data, 'base64');
-                const float32Array = new Float32Array(decodedData.buffer);
-
-                // Convert Float32 to Int16 for web audio playback
-                const int16Array = new Int16Array(float32Array.length);
-                for (let i = 0; i < float32Array.length; i++) {
-                  int16Array[i] = Math.max(
-                    -32768,
-                    Math.min(32767, float32Array[i] * 32767)
-                  );
-                }
-                const base64Audio = Buffer.from(int16Array.buffer).toString(
-                  'base64'
-                );
-
-                // Send immediately without buffering
-                if (this.websocket) {
-                  this.websocket.send(
-                    JSON.stringify({
-                      type: 'audio_stream',
-                      audio: base64Audio,
-                      sampleRate: ttsChunk.audio.sampleRate || 16000,
-                      timestamp: Date.now(),
-                      text: ttsChunk.text || '',
-                      isFirstChunk: isFirstChunk,
-                    })
-                  );
-                }
-
-                // Mark that we've sent the first chunk
-                isFirstChunk = false;
-              }
-            }
-            // Send completion signal for iOS
-            console.log('VAD TTS stream complete, sending completion signal');
-            if (this.websocket) {
-              this.websocket.send(
-                JSON.stringify({
-                  type: 'audio_stream_complete',
-                  timestamp: Date.now(),
-                })
-              );
-            }
-
-            // Now that TTS is complete, trigger flashcard generation and other post-processing
-            if (transcription && llmResponse) {
-              console.log(
-                'Triggering flashcard generation after TTS completion'
-              );
-
-              // Send conversation update to frontend
-              if (this.websocket) {
-                this.websocket.send(
-                  JSON.stringify({
-                    type: 'conversation_update',
-                    messages: this.conversationState.messages,
-                    timestamp: Date.now(),
-                  })
-                );
-              }
-
-              // Generate flashcards - fire and forget
-              if (this.flashcardCallback) {
-                const recentMessages = this.conversationState.messages
-                  .slice(-6)
-                  .map((msg) => ({
-                    role: msg.role,
-                    content: msg.content,
-                  }));
-
-                this.flashcardCallback(recentMessages).catch((error) => {
-                  console.error(
-                    'Error in flashcard generation callback:',
-                    error
-                  );
-                });
-              }
-
-              // Run introduction-state extraction while incomplete
-              const isIntroComplete = Boolean(
-                this.introductionState?.name &&
-                  this.introductionState?.level &&
-                  this.introductionState?.goal
-              );
-              if (!isIntroComplete && this.introductionStateCallback) {
-                const recentMessages = this.conversationState.messages
-                  .slice(-6)
-                  .map((msg) => ({
-                    role: msg.role,
-                    content: msg.content,
-                  }));
-
-                this.introductionStateCallback(recentMessages)
-                  .then((state) => {
-                    if (state) {
-                      this.introductionState = state;
-                      if (this.websocket) {
-                        this.websocket.send(
-                          JSON.stringify({
-                            type: 'introduction_state_updated',
-                            introduction_state: this.introductionState,
-                            timestamp: Date.now(),
-                          })
-                        );
-                      }
-                    }
-                  })
-                  .catch((error) => {
-                    console.error(
-                      'Error in introduction-state callback:',
-                      error
-                    );
-                  });
-              }
-            }
-          },
-
-          // Handle any other type
-          default: (data: unknown) => {
-            console.log(
-              `VAD Unknown/unhandled chunk type: ${chunk.typeName}`,
-              data
-            );
-          },
-        });
-
-        // Check again after processing each chunk
-        if (this.isProcessingCancelled) {
-          console.log('Processing cancelled after chunk processing');
-          break;
-        }
-      }
-    } catch (error) {
-      console.error('Error processing VAD speech segment:', error);
-    } finally {
-      this.isProcessing = false;
-
-      // If we have pending segments (user spoke while we were processing), process them now
-      if (
-        this.pendingSpeechSegments.length > 0 &&
-        !this.isProcessingCancelled
-      ) {
-        console.log(
-          'Found pending segments after processing, processing them now'
-        );
-
-        // Combine all pending segments
-        const totalLength = this.pendingSpeechSegments.reduce(
-          (sum, seg) => sum + seg.length,
-          0
-        );
-        const combinedSegment = new Float32Array(totalLength);
-        let offset = 0;
-        for (const seg of this.pendingSpeechSegments) {
-          combinedSegment.set(seg, offset);
-          offset += seg.length;
-        }
-
-        // Clear pending segments
-        this.pendingSpeechSegments = [];
-
-        // Process the combined segments recursively
-        await this.processVADSpeechSegment(combinedSegment);
-      }
-    }
-  }
-
-  reset() {
-    // Clear conversation state
-    this.conversationState = {
-      messages: [],
-    };
-    // Clear pending segments
-    this.pendingSpeechSegments = [];
-    // Reset introduction state
-    this.introductionState = {
-      name: '',
-      level: '',
-      goal: '',
-      timestamp: '',
-    };
-    // Cancel any ongoing processing
-    this.isProcessingCancelled = true;
-    console.log('AudioProcessor: Conversation reset');
-  }
-
-  async destroy() {
-    if (this.vad) {
-      try {
-        this.vad.destroy();
-      } catch (error) {
-        console.error('Error destroying VAD:', error);
-        // Continue with cleanup even if destroy fails
-      }
-      this.vad = null;
-    }
-  }
-}
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
new file mode 100644
index 0000000..f395862
--- /dev/null
+++ b/backend/helpers/connection-manager.ts
@@ -0,0 +1,580 @@
+/**
+ * ConnectionManager - Manages WebSocket connections and graph execution
+ *
+ * This replaces the AudioProcessor for Inworld Runtime 0.9.
+ * Key differences from AudioProcessor:
+ * - Uses MultimodalStreamManager to feed audio to a long-running graph
+ * - VAD is handled inside the graph by AssemblyAI (not external Silero)
+ * - Graph runs continuously for the session duration
+ */
+
+import { WebSocket } from 'ws';
+import { GraphTypes } from '@inworld/runtime/graph';
+
+import { ConversationGraphWrapper } from '../components/graphs/conversation-graph.js';
+import { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager.js';
+import { decodeBase64ToFloat32 } from '../components/audio/audio_utils.js';
+import { ConnectionsMap, INPUT_SAMPLE_RATE, TTS_SAMPLE_RATE } from '../types/index.js';
+import {
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+  LanguageConfig,
+} from '../config/languages.js';
+import type { IntroductionState } from './introduction-state-processor.js';
+
+export class ConnectionManager {
+  private sessionId: string;
+  private ws: WebSocket;
+  private graphWrapper: ConversationGraphWrapper;
+  private multimodalStreamManager: MultimodalStreamManager;
+  private connections: ConnectionsMap;
+  private graphExecution: Promise<void> | null = null;
+  private isDestroyed = false;
+  private languageCode: string;
+  private languageConfig: LanguageConfig;
+
+  // Callbacks for flashcard and introduction state processing
+  private flashcardCallback:
+    | ((messages: Array<{ role: string; content: string }>) => Promise<void>)
+    | null = null;
+  private introductionStateCallback:
+    | ((
+        messages: Array<{ role: string; content: string }>
+      ) => Promise<IntroductionState | null>)
+    | null = null;
+
+  constructor(
+    sessionId: string,
+    ws: WebSocket,
+    graphWrapper: ConversationGraphWrapper,
+    connections: ConnectionsMap,
+    languageCode: string = DEFAULT_LANGUAGE_CODE
+  ) {
+    this.sessionId = sessionId;
+    this.ws = ws;
+    this.graphWrapper = graphWrapper;
+    this.connections = connections;
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
+    this.multimodalStreamManager = new MultimodalStreamManager();
+
+    // Initialize connection state
+    this.connections[sessionId] = {
+      ws: ws,
+      state: {
+        interactionId: '',
+        messages: [],
+        userName: '',
+        targetLanguage: this.languageConfig.name,
+        languageCode: languageCode,
+        voiceId: this.languageConfig.ttsConfig.speakerId,
+        introductionState: { name: '', level: '', goal: '', timestamp: '' },
+        output_modalities: ['audio', 'text'],
+      },
+      multimodalStreamManager: this.multimodalStreamManager,
+      onSpeechDetected: (interactionId) =>
+        this.handleSpeechDetected(interactionId),
+      onPartialTranscript: (text, interactionId) =>
+        this.handlePartialTranscript(text, interactionId),
+    };
+
+    console.log(
+      `[ConnectionManager] Created for session ${sessionId} with language ${this.languageConfig.name}`
+    );
+  }
+
+  /**
+   * Start the long-running graph execution
+   */
+  async start(): Promise<void> {
+    console.log(`[ConnectionManager] Starting graph for session ${this.sessionId}`);
+
+    // Create the multimodal stream generator
+    const multimodalStream = this.createMultimodalStreamGenerator();
+
+    // Start graph execution (runs in background)
+    this.graphExecution = this.executeGraph(multimodalStream);
+
+    // Don't await - the graph runs continuously
+    this.graphExecution.catch((error) => {
+      if (!this.isDestroyed) {
+        console.error(`[ConnectionManager] Graph execution error:`, error);
+      }
+    });
+  }
+
+  /**
+   * Create an async generator that yields multimodal content from the stream manager
+   */
+  private async *createMultimodalStreamGenerator(): AsyncGenerator<GraphTypes.MultimodalContent> {
+    for await (const content of this.multimodalStreamManager.createStream()) {
+      yield content;
+    }
+  }
+
+  /**
+   * Execute the graph with the multimodal stream
+   */
+  private async executeGraph(
+    stream: AsyncGenerator<GraphTypes.MultimodalContent>
+  ): Promise<void> {
+    const connection = this.connections[this.sessionId];
+    if (!connection) {
+      throw new Error(`No connection found for session ${this.sessionId}`);
+    }
+
+    // Tag the stream for the runtime
+    const taggedStream = Object.assign(stream, {
+      type: 'MultimodalContent',
+    });
+
+    console.log(`[ConnectionManager] Starting graph execution for ${this.sessionId}`);
+
+    const { outputStream } = await this.graphWrapper.graph.start(taggedStream, {
+      executionId: this.sessionId,
+      dataStoreContent: {
+        sessionId: this.sessionId,
+        state: connection.state,
+      },
+      userContext: {
+        attributes: {
+          languageCode: this.languageCode,
+          language: this.languageConfig.name,
+        },
+        targetingKey: this.sessionId,
+      },
+    });
+
+    // Store the output stream for potential cancellation
+    connection.currentAudioExecutionStream = outputStream;
+
+    // Process graph outputs
+    try {
+      for await (const result of outputStream) {
+        if (this.isDestroyed) break;
+        await this.processGraphOutput(result);
+      }
+    } catch (error) {
+      if (!this.isDestroyed) {
+        console.error(`[ConnectionManager] Error processing output:`, error);
+      }
+    } finally {
+      connection.currentAudioExecutionStream = undefined;
+    }
+
+    console.log(`[ConnectionManager] Graph execution completed for ${this.sessionId}`);
+  }
+
+  /**
+   * Process a single output from the graph
+   */
+  private async processGraphOutput(result: unknown): Promise<void> {
+    const connection = this.connections[this.sessionId];
+    if (!connection) return;
+
+    let transcription = '';
+    let llmResponse = '';
+
+    try {
+      // Cast to any to work around strict typing issues with processResponse handlers
+      // The handlers receive typed data at runtime even though the type system says unknown
+      const resultWithProcess = result as { processResponse: (handlers: Record<string, (data: unknown) => Promise<void> | void>) => Promise<void> };
+      await resultWithProcess.processResponse({
+        // Handle string output (transcription from proxy node)
+        string: (data: unknown) => {
+          transcription = String(data);
+          if (transcription.trim()) {
+            console.log(`[ConnectionManager] Transcription: "${transcription}"`);
+            this.sendToClient({
+              type: 'transcription',
+              text: transcription.trim(),
+              timestamp: Date.now(),
+            });
+
+            // Trigger introduction state extraction
+            this.triggerIntroductionStateExtraction();
+          }
+        },
+
+        // Handle Custom data (transcription from transcript extractor)
+        // InteractionInfo has: sessionId, interactionId, text, interactionComplete
+        Custom: async (customData: unknown) => {
+          const data = customData as { text?: string; interactionId?: string; interactionComplete?: boolean };
+          // Only send final transcriptions (interactionComplete=true) to avoid duplicates
+          if (data.text && data.interactionComplete) {
+            transcription = data.text;
+            console.log(`[ConnectionManager] Transcription (final): "${transcription}"`);
+            this.sendToClient({
+              type: 'transcription',
+              text: transcription.trim(),
+              timestamp: Date.now(),
+            });
+            this.triggerIntroductionStateExtraction();
+          }
+        },
+
+        // Handle LLM response stream
+        ContentStream: async (streamData: unknown) => {
+          const stream = streamData as GraphTypes.ContentStream;
+          console.log('[ConnectionManager] Processing LLM ContentStream...');
+          let currentResponse = '';
+
+          for await (const chunk of stream) {
+            if (this.isDestroyed) break;
+            if (chunk.text) {
+              currentResponse += chunk.text;
+              this.sendToClient({
+                type: 'llm_response_chunk',
+                text: chunk.text,
+                timestamp: Date.now(),
+              });
+            }
+          }
+
+          if (currentResponse.trim()) {
+            llmResponse = currentResponse;
+            console.log(
+              `[ConnectionManager] LLM Response complete: "${llmResponse.substring(0, 50)}..."`
+            );
+            this.sendToClient({
+              type: 'llm_response_complete',
+              text: llmResponse.trim(),
+              timestamp: Date.now(),
+            });
+          }
+        },
+
+        // Handle TTS output stream
+        TTSOutputStream: async (ttsData: unknown) => {
+          const ttsStream = ttsData as GraphTypes.TTSOutputStream;
+          console.log('[ConnectionManager] Processing TTS stream...');
+          let isFirstChunk = true;
+
+          for await (const chunk of ttsStream) {
+            if (this.isDestroyed) break;
+            if (chunk.audio?.data) {
+              // Log sample rate on first chunk
+              if (isFirstChunk) {
+                console.log(`[ConnectionManager] TTS audio: sampleRate=${chunk.audio.sampleRate || TTS_SAMPLE_RATE}, bytes=${Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A'}`);
+              }
+
+              // Convert audio to base64 for WebSocket transmission
+              // Use TTS_SAMPLE_RATE as fallback (not INPUT_SAMPLE_RATE which is for microphone input)
+              const audioResult = this.convertAudioToBase64(chunk.audio);
+              if (audioResult) {
+                this.sendToClient({
+                  type: 'audio_stream',
+                  audio: audioResult.base64,
+                  audioFormat: audioResult.format,
+                  sampleRate: chunk.audio.sampleRate || TTS_SAMPLE_RATE,
+                  text: chunk.text || '',
+                  isFirstChunk: isFirstChunk,
+                  timestamp: Date.now(),
+                });
+                isFirstChunk = false;
+              }
+            }
+          }
+
+          // Send completion signal
+          console.log('[ConnectionManager] TTS stream complete');
+          this.sendToClient({
+            type: 'audio_stream_complete',
+            timestamp: Date.now(),
+          });
+
+          // Send conversation update
+          this.sendToClient({
+            type: 'conversation_update',
+            messages: connection.state.messages,
+            timestamp: Date.now(),
+          });
+
+          // Trigger flashcard generation after TTS completes
+          this.triggerFlashcardGeneration();
+        },
+
+        // Handle errors
+        error: async (error: unknown) => {
+          const err = error as { message?: string };
+          console.error('[ConnectionManager] Graph error:', err);
+          if (!err.message?.includes('recognition produced no text')) {
+            this.sendToClient({
+              type: 'error',
+              message: err.message || 'Unknown error',
+              timestamp: Date.now(),
+            });
+          }
+        },
+
+        // Default handler for unknown types
+        default: (_data: unknown) => {
+          // console.log('[ConnectionManager] Unknown output type:', data);
+        },
+      });
+    } catch (error) {
+      console.error('[ConnectionManager] Error processing graph output:', error);
+    }
+  }
+
+  /**
+   * Add an audio chunk from the WebSocket
+   */
+  addAudioChunk(base64Audio: string): void {
+    if (this.isDestroyed) return;
+
+    try {
+      // Decode base64 to Float32Array
+      const float32Data = decodeBase64ToFloat32(base64Audio);
+
+      // Push to multimodal stream
+      this.multimodalStreamManager.pushAudio({
+        data: Array.from(float32Data),
+        sampleRate: INPUT_SAMPLE_RATE,
+      });
+    } catch (error) {
+      console.error('[ConnectionManager] Error adding audio chunk:', error);
+    }
+  }
+
+  /**
+   * Handle speech detected event from AssemblyAI
+   */
+  private handleSpeechDetected(interactionId: string): void {
+    console.log(`[ConnectionManager] Speech detected: ${interactionId}`);
+    this.sendToClient({
+      type: 'speech_detected',
+      interactionId,
+      data: { text: '' },
+      timestamp: Date.now(),
+    });
+
+    // Could also send interrupt signal here if needed
+    this.sendToClient({
+      type: 'interrupt',
+      reason: 'speech_start',
+    });
+  }
+
+  /**
+   * Handle partial transcript from AssemblyAI
+   */
+  private handlePartialTranscript(text: string, interactionId: string): void {
+    this.sendToClient({
+      type: 'partial_transcript',
+      text,
+      interactionId,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Convert audio data to base64 string for WebSocket transmission
+   * Inworld TTS returns Float32 PCM in [-1.0, 1.0] range - send directly to preserve quality
+   */
+  private convertAudioToBase64(audio: {
+    data?: string | number[] | Float32Array;
+    sampleRate?: number;
+  }): { base64: string; format: 'float32' | 'int16' } | null {
+    if (!audio.data) return null;
+
+    if (typeof audio.data === 'string') {
+      // Already base64 - assume Int16 format for backwards compatibility
+      return { base64: audio.data, format: 'int16' };
+    }
+
+    // Inworld SDK returns audio.data as an array of raw bytes (0-255)
+    // These bytes ARE the Float32 PCM data in IEEE 754 format (4 bytes per sample)
+    // Simply pass them through as-is, and frontend interprets as Float32Array
+    const audioBuffer = Array.isArray(audio.data)
+      ? Buffer.from(audio.data)  // Treat each array element as a byte
+      : Buffer.from(audio.data.buffer, audio.data.byteOffset, audio.data.byteLength);
+
+    return {
+      base64: audioBuffer.toString('base64'),
+      format: 'float32',  // Frontend will interpret bytes as Float32Array
+    };
+  }
+
+  /**
+   * Send message to WebSocket client
+   */
+  private sendToClient(message: Record<string, unknown>): void {
+    if (this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(message));
+      } catch (error) {
+        console.error('[ConnectionManager] Error sending to client:', error);
+      }
+    }
+  }
+
+  /**
+   * Trigger flashcard generation
+   */
+  private triggerFlashcardGeneration(): void {
+    if (!this.flashcardCallback) return;
+
+    const connection = this.connections[this.sessionId];
+    if (!connection) return;
+
+    const recentMessages = connection.state.messages.slice(-6).map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    this.flashcardCallback(recentMessages).catch((error) => {
+      console.error('[ConnectionManager] Flashcard generation error:', error);
+    });
+  }
+
+  /**
+   * Trigger introduction state extraction
+   */
+  private triggerIntroductionStateExtraction(): void {
+    if (!this.introductionStateCallback) return;
+
+    const connection = this.connections[this.sessionId];
+    if (!connection) return;
+
+    // Skip if introduction is already complete
+    const intro = connection.state.introductionState;
+    if (intro.name && intro.level && intro.goal) {
+      return;
+    }
+
+    const recentMessages = connection.state.messages.slice(-6).map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    this.introductionStateCallback(recentMessages)
+      .then((state) => {
+        if (state) {
+          connection.state.introductionState = state;
+          this.sendToClient({
+            type: 'introduction_state_updated',
+            introduction_state: state,
+            timestamp: Date.now(),
+          });
+        }
+      })
+      .catch((error) => {
+        console.error('[ConnectionManager] Introduction state error:', error);
+      });
+  }
+
+  // ============================================================
+  // Public API (compatible with AudioProcessor)
+  // ============================================================
+
+  setFlashcardCallback(
+    callback: (
+      messages: Array<{ role: string; content: string }>
+    ) => Promise<void>
+  ): void {
+    this.flashcardCallback = callback;
+  }
+
+  setIntroductionStateCallback(
+    callback: (
+      messages: Array<{ role: string; content: string }>
+    ) => Promise<IntroductionState | null>
+  ): void {
+    this.introductionStateCallback = callback;
+  }
+
+  getConversationState(): { messages: Array<{ role: string; content: string; timestamp: string }> } {
+    const connection = this.connections[this.sessionId];
+    return {
+      messages:
+        connection?.state.messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+          timestamp: m.timestamp || new Date().toISOString(),
+        })) || [],
+    };
+  }
+
+  getIntroductionState(): IntroductionState {
+    const connection = this.connections[this.sessionId];
+    return (
+      connection?.state.introductionState || {
+        name: '',
+        level: '',
+        goal: '',
+        timestamp: '',
+      }
+    );
+  }
+
+  getLanguageCode(): string {
+    return this.languageCode;
+  }
+
+  getLanguageConfig(): LanguageConfig {
+    return this.languageConfig;
+  }
+
+  /**
+   * Change language for this session
+   */
+  setLanguage(newLanguageCode: string): void {
+    if (this.languageCode === newLanguageCode) return;
+
+    console.log(
+      `[ConnectionManager] Changing language from ${this.languageCode} to ${newLanguageCode}`
+    );
+
+    this.languageCode = newLanguageCode;
+    this.languageConfig = getLanguageConfig(newLanguageCode);
+
+    const connection = this.connections[this.sessionId];
+    if (connection) {
+      connection.state.languageCode = newLanguageCode;
+      connection.state.targetLanguage = this.languageConfig.name;
+      connection.state.voiceId = this.languageConfig.ttsConfig.speakerId;
+    }
+
+    console.log(
+      `[ConnectionManager] Language changed to ${this.languageConfig.name}`
+    );
+  }
+
+  /**
+   * Reset conversation state
+   */
+  reset(): void {
+    const connection = this.connections[this.sessionId];
+    if (connection) {
+      connection.state.messages = [];
+      connection.state.introductionState = {
+        name: '',
+        level: '',
+        goal: '',
+        timestamp: '',
+      };
+      connection.state.interactionId = '';
+    }
+    console.log('[ConnectionManager] Conversation reset');
+  }
+
+  /**
+   * Clean up resources
+   */
+  async destroy(): Promise<void> {
+    console.log(`[ConnectionManager] Destroying session ${this.sessionId}`);
+    this.isDestroyed = true;
+
+    // End the multimodal stream
+    this.multimodalStreamManager.end();
+
+    // Close AssemblyAI session
+    await this.graphWrapper.assemblyAINode.closeSession(this.sessionId);
+
+    // Remove from connections map
+    delete this.connections[this.sessionId];
+
+    console.log(`[ConnectionManager] Session ${this.sessionId} destroyed`);
+  }
+}
diff --git a/backend/helpers/silero-vad.ts b/backend/helpers/silero-vad.ts
deleted file mode 100644
index 83c0eee..0000000
--- a/backend/helpers/silero-vad.ts
+++ /dev/null
@@ -1,287 +0,0 @@
-import { EventEmitter } from 'events';
-import { VADFactory } from '@inworld/runtime/primitives/vad';
-import { DeviceRegistry, DeviceType } from '@inworld/runtime/core';
-import { AudioBuffer, AudioChunk } from './audio-buffer.js';
-
-export interface VADConfig {
-  modelPath: string;
-  threshold: number;
-  minSpeechDuration: number; // seconds
-  minSilenceDuration: number; // seconds
-  speechResetSilenceDuration: number; // grace period before resetting speech timer
-  minVolume: number; // minimum RMS volume for speech (0.0-1.0)
-  sampleRate: number;
-}
-
-export interface VADResult {
-  isSpeech: boolean;
-  confidence: number;
-  timestamp: number;
-}
-
-// VAD type from the runtime library - using unknown since the exact type isn't exported
-type VADInstance = {
-  detectVoiceActivity: (config: {
-    data: number[];
-    sampleRate: number;
-  }) => Promise<number>;
-  destroy: () => void;
-};
-
-export class SileroVAD extends EventEmitter {
-  private vad: VADInstance | null = null;
-  private config: VADConfig;
-  private audioBuffer: AudioBuffer;
-  private accumulatedSamples: Float32Array[] = [];
-  private isInitialized = false;
-  private isProcessingVAD = false; // Prevent concurrent VAD calls
-
-  // Simplified state tracking following working example pattern
-  private isCapturingSpeech = false;
-  private speechBuffer: number[] = [];
-  private pauseDuration = 0;
-  private readonly FRAME_PER_BUFFER = 1024;
-  private readonly INPUT_SAMPLE_RATE = 16000;
-
-  constructor(config: VADConfig) {
-    super();
-    this.config = config;
-    this.audioBuffer = new AudioBuffer(20, config.sampleRate);
-
-    // Listen to audio chunks from buffer
-    this.audioBuffer.on('audioChunk', this.processAudioChunk.bind(this));
-  }
-
-  async initialize(): Promise<void> {
-    if (this.isInitialized) {
-      console.log('SileroVAD: Already initialized');
-      return;
-    }
-
-    try {
-      console.log(
-        'SileroVAD: Starting initialization with model path:',
-        this.config.modelPath
-      );
-
-      // Try to find CUDA device
-      const availableDevices = DeviceRegistry.getAvailableDevices();
-      console.log(
-        'SileroVAD: Available devices:',
-        availableDevices.map((d) => d.getType())
-      );
-
-      const cudaDevice = availableDevices.find(
-        (device) => device.getType() === DeviceType.CUDA
-      );
-      console.log('SileroVAD: Using CUDA device:', !!cudaDevice);
-
-      // Create local VAD instance
-      console.log('SileroVAD: Creating VAD instance...');
-      this.vad = await VADFactory.createLocal({
-        modelPath: this.config.modelPath,
-        device: cudaDevice,
-      });
-
-      this.isInitialized = true;
-      console.log('SileroVAD: Initialization complete');
-    } catch (error) {
-      console.error('SileroVAD: Failed to initialize:', error);
-      throw error;
-    }
-  }
-
-  addAudioData(base64Data: string): void {
-    try {
-      // Convert base64 to buffer (same as working example needs)
-      const binaryString = Buffer.from(base64Data, 'base64').toString('binary');
-      const bytes = new Uint8Array(binaryString.length);
-
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-
-      // Convert to Int16Array then normalize to Float32 range [-1, 1]
-      const int16Array = new Int16Array(bytes.buffer);
-
-      // Convert to normalized Float32Array for consistent audio processing
-      const normalizedArray = new Float32Array(int16Array.length);
-      for (let i = 0; i < int16Array.length; i++) {
-        normalizedArray[i] = int16Array[i] / 32768.0; // Normalize to [-1, 1] range
-      }
-
-      // Add to audio buffer with normalized Float32Array
-      this.audioBuffer.addChunk(normalizedArray);
-    } catch (error) {
-      console.error('SileroVAD: Error processing audio data:', error);
-    }
-  }
-
-  private calculateRMSVolume(audioData: Float32Array): number {
-    let sumSquares = 0;
-    for (let i = 0; i < audioData.length; i++) {
-      sumSquares += audioData[i] * audioData[i];
-    }
-    return Math.sqrt(sumSquares / audioData.length);
-  }
-
-  reset(): void {
-    // Reset all state when interruption occurs
-    this.accumulatedSamples = [];
-    this.isProcessingVAD = false;
-    this.isCapturingSpeech = false;
-    this.speechBuffer = [];
-    this.pauseDuration = 0;
-  }
-
-  private async processAudioChunk(chunk: AudioChunk): Promise<void> {
-    if (!this.isInitialized || !this.vad) {
-      return;
-    }
-
-    // Skip if already processing to prevent concurrent VAD calls
-    if (this.isProcessingVAD) {
-      return;
-    }
-
-    // Accumulate samples until we have enough for VAD processing
-    this.accumulatedSamples.push(chunk.data);
-
-    // Process when we have enough samples (using FRAME_PER_BUFFER like working example)
-    const totalSamples = this.accumulatedSamples.reduce(
-      (sum, arr) => sum + arr.length,
-      0
-    );
-    if (totalSamples >= this.FRAME_PER_BUFFER) {
-      this.isProcessingVAD = true; // Set flag before async operation
-      try {
-        // Combine accumulated samples
-        const combinedAudio = new Float32Array(totalSamples);
-        let offset = 0;
-        for (const samples of this.accumulatedSamples) {
-          combinedAudio.set(samples, offset);
-          offset += samples.length;
-        }
-
-        // Calculate RMS volume for noise filtering
-        const rmsVolume = this.calculateRMSVolume(combinedAudio);
-
-        // Convert normalized Float32Array back to integer array for VAD model
-        const integerArray: number[] = [];
-        for (let i = 0; i < combinedAudio.length; i++) {
-          // Convert back to Int16 range for VAD processing
-          integerArray.push(Math.round(combinedAudio[i] * 32768));
-        }
-
-        // Process with Silero VAD
-        const result = await this.vad.detectVoiceActivity({
-          data: integerArray,
-          sampleRate: this.config.sampleRate,
-        });
-
-        // Following working example: -1 = no voice activity, anything else = voice activity
-        // Add volume filtering to the working pattern
-        const hasVoiceActivity =
-          result !== -1 && rmsVolume >= this.config.minVolume;
-
-        // Process using simplified state machine from working example
-        await this.processVADResult(hasVoiceActivity, integerArray, rmsVolume);
-
-        // Clear accumulated samples
-        this.accumulatedSamples = [];
-      } catch (error) {
-        console.error('VAD processing error:', error);
-        this.accumulatedSamples = []; // Clear on error
-      } finally {
-        this.isProcessingVAD = false; // Always reset flag
-      }
-    }
-  }
-
-  private async processVADResult(
-    hasVoiceActivity: boolean,
-    audioChunk: number[],
-    volume: number
-  ): Promise<void> {
-    // Following the working example pattern exactly
-    if (this.isCapturingSpeech) {
-      this.speechBuffer.push(...audioChunk);
-      if (!hasVoiceActivity) {
-        // Already capturing speech but new chunk has no voice activity
-        this.pauseDuration +=
-          (audioChunk.length * 1000) / this.INPUT_SAMPLE_RATE; // ms
-
-        if (this.pauseDuration > this.config.minSilenceDuration * 1000) {
-          // Convert to ms
-          this.isCapturingSpeech = false;
-
-          const speechDuration =
-            (this.speechBuffer.length * 1000) / this.INPUT_SAMPLE_RATE; // ms
-
-          if (speechDuration > this.config.minSpeechDuration * 1000) {
-            // Convert to ms
-            await this.processCapturedSpeech();
-          } else {
-            // Speech was too short, but still emit speechEnd to notify that VAD stopped detecting
-            this.emit('speechEnd', {
-              timestamp: Date.now() / 1000,
-              speechSegment: null, // No segment to process
-              speechDuration: speechDuration / 1000,
-              samplesCount: this.speechBuffer.length,
-            });
-          }
-
-          // Reset for next speech capture
-          this.speechBuffer = [];
-          this.pauseDuration = 0;
-        }
-      } else {
-        // Already capturing speech and new chunk has voice activity
-        this.pauseDuration = 0;
-      }
-    } else {
-      if (hasVoiceActivity) {
-        // Not capturing speech but new chunk has voice activity - start capturing
-        this.isCapturingSpeech = true;
-        this.speechBuffer = [...audioChunk]; // Start fresh
-        this.pauseDuration = 0;
-
-        this.emit('speechStart', {
-          timestamp: Date.now() / 1000,
-          volume,
-        });
-      }
-      // Not capturing speech and new chunk has no voice activity - do nothing
-    }
-  }
-
-  private async processCapturedSpeech(): Promise<void> {
-    if (this.speechBuffer.length === 0) return;
-
-    // Convert integer array back to Float32Array for processing
-    const speechSegment = new Float32Array(this.speechBuffer.length);
-    for (let i = 0; i < this.speechBuffer.length; i++) {
-      speechSegment[i] = this.speechBuffer[i] / 32768.0; // Normalize back to [-1, 1]
-    }
-
-    const speechDuration =
-      (this.speechBuffer.length * 1000) / this.INPUT_SAMPLE_RATE;
-
-    this.emit('speechEnd', {
-      timestamp: Date.now() / 1000,
-      speechSegment,
-      speechDuration: speechDuration / 1000, // Convert back to seconds
-      samplesCount: this.speechBuffer.length,
-    });
-  }
-
-  destroy(): void {
-    if (this.vad) {
-      this.vad.destroy();
-      this.vad = null;
-    }
-
-    this.audioBuffer.clear();
-    this.isInitialized = false;
-  }
-}
diff --git a/backend/server.ts b/backend/server.ts
index 23af9a7..110f7e2 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -1,3 +1,14 @@
+/**
+ * Language Learning Server - Inworld Runtime 0.9
+ *
+ * This server uses a long-running circular graph with AssemblyAI for VAD/STT.
+ * Key components:
+ * - ConversationGraphWrapper: The main graph that processes audio → STT → LLM → TTS
+ * - ConnectionManager: Manages WebSocket connections and feeds audio to the graph
+ * - FlashcardProcessor: Generates flashcards from conversations
+ * - IntroductionStateProcessor: Extracts user info (name, level, goal)
+ */
+
 // Load environment variables FIRST
 import dotenv from 'dotenv';
 dotenv.config();
@@ -14,14 +25,16 @@ import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
 import { telemetry, stopInworldRuntime } from '@inworld/runtime';
 import { MetricType } from '@inworld/runtime/telemetry';
-import { UserContextInterface } from '@inworld/runtime/graph';
 
-// Import our audio processor
-import { AudioProcessor } from './helpers/audio-processor.js';
+// Import new 0.9 components
+import { ConversationGraphWrapper } from './components/graphs/conversation-graph.js';
+import { ConnectionManager } from './helpers/connection-manager.js';
+import { ConnectionsMap } from './types/index.js';
+
+// Import existing components (still compatible)
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
-import { AnkiExporter } from './helpers/anki-exporter.js';
+// import { AnkiExporter } from './helpers/anki-exporter.js';
 import { IntroductionStateProcessor } from './helpers/introduction-state-processor.js';
-import { getConversationGraph } from './graphs/conversation-graph.js';
 import {
   getLanguageConfig,
   getLanguageOptions,
@@ -37,7 +50,32 @@ app.use(express.json());
 
 const PORT = process.env.PORT || 3000;
 
-// Initialize telemetry once at startup
+// ============================================================
+// Global State
+// ============================================================
+
+// Shared connections map (used by graph nodes)
+const connections: ConnectionsMap = {};
+
+// Graph wrapper (created once, shared across all connections)
+let graphWrapper: ConversationGraphWrapper | null = null;
+
+// Connection managers per WebSocket
+const connectionManagers = new Map<string, ConnectionManager>();
+const flashcardProcessors = new Map<string, FlashcardProcessor>();
+const introductionStateProcessors = new Map<string, IntroductionStateProcessor>();
+const connectionAttributes = new Map<
+  string,
+  { timezone?: string; userId?: string; languageCode?: string }
+>();
+
+// Shutdown flag
+let isShuttingDown = false;
+
+// ============================================================
+// Initialize Telemetry
+// ============================================================
+
 try {
   const telemetryApiKey = process.env.INWORLD_API_KEY;
   if (telemetryApiKey) {
@@ -54,84 +92,88 @@ try {
       unit: 'clicks',
     });
   } else {
-    console.warn(
-      '[Telemetry] INWORLD_API_KEY not set. Metrics will be disabled.'
-    );
+    console.warn('[Telemetry] INWORLD_API_KEY not set. Metrics will be disabled.');
   }
 } catch (err) {
   console.error('[Telemetry] Initialization failed:', err);
 }
 
-// Store audio processors per connection
-const audioProcessors = new Map<string, AudioProcessor>();
-const flashcardProcessors = new Map<string, FlashcardProcessor>();
-const introductionStateProcessors = new Map<
-  string,
-  IntroductionStateProcessor
->();
-// Store lightweight per-connection attributes provided by the client (e.g., timezone, userId, languageCode)
-const connectionAttributes = new Map<
-  string,
-  { timezone?: string; userId?: string; languageCode?: string }
->();
+// ============================================================
+// Initialize Graph
+// ============================================================
 
-/**
- * Get or create a conversation graph for the specified language
- */
-function getGraphForLanguage(languageCode: string) {
-  const apiKey = process.env.INWORLD_API_KEY || '';
-  return getConversationGraph({ apiKey }, languageCode);
+async function initializeGraph(): Promise<void> {
+  const assemblyAIApiKey = process.env.ASSEMBLY_AI_API_KEY;
+  if (!assemblyAIApiKey) {
+    throw new Error('ASSEMBLY_AI_API_KEY environment variable is required');
+  }
+
+  console.log('[Server] Creating conversation graph...');
+  graphWrapper = ConversationGraphWrapper.create({
+    assemblyAIApiKey,
+    connections,
+    defaultLanguageCode: DEFAULT_LANGUAGE_CODE,
+  });
+  console.log('[Server] Conversation graph created successfully');
 }
 
-// WebSocket handling with audio processing
-wss.on('connection', (ws) => {
+// ============================================================
+// WebSocket Connection Handler
+// ============================================================
+
+wss.on('connection', async (ws) => {
+  if (!graphWrapper) {
+    console.error('[Server] Graph not initialized, rejecting connection');
+    ws.close(1011, 'Server not ready');
+    return;
+  }
+
   const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  console.log(`WebSocket connection established: ${connectionId}`);
+  console.log(`[Server] WebSocket connection established: ${connectionId}`);
 
   // Default language is Spanish
   const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
 
-  // Create processors with default language
-  const graph = getGraphForLanguage(defaultLanguageCode);
-  const audioProcessor = new AudioProcessor(graph, ws, defaultLanguageCode);
-  const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
-  const introductionStateProcessor = new IntroductionStateProcessor(
+  // Create connection manager (replaces AudioProcessor)
+  const connectionManager = new ConnectionManager(
+    connectionId,
+    ws,
+    graphWrapper,
+    connections,
     defaultLanguageCode
   );
 
-  // Register processors
-  audioProcessors.set(connectionId, audioProcessor);
+  // Create flashcard and introduction state processors
+  const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
+  const introductionStateProcessor = new IntroductionStateProcessor(defaultLanguageCode);
+
+  // Store processors
+  connectionManagers.set(connectionId, connectionManager);
   flashcardProcessors.set(connectionId, flashcardProcessor);
   introductionStateProcessors.set(connectionId, introductionStateProcessor);
   connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
 
   // Set up flashcard generation callback
-  audioProcessor.setFlashcardCallback(async (messages) => {
-    // Skip flashcard generation if we're shutting down
+  connectionManager.setFlashcardCallback(async (messages) => {
     if (isShuttingDown) {
-      console.log('Skipping flashcard generation - server is shutting down');
+      console.log('[Server] Skipping flashcard generation - shutting down');
       return;
     }
 
     try {
-      // Build UserContext for flashcard graph execution
       const introState = introductionStateProcessor.getState();
       const attrs = connectionAttributes.get(connectionId) || {};
       const userAttributes: Record<string, string> = {
         timezone: attrs.timezone || '',
       };
-      userAttributes.name =
-        (introState?.name && introState.name.trim()) || 'unknown';
-      userAttributes.level =
-        (introState?.level && (introState.level as string)) || 'unknown';
-      userAttributes.goal =
-        (introState?.goal && introState.goal.trim()) || 'unknown';
-
-      // Prefer a stable targeting key from client if available, fallback to connectionId
+      userAttributes.name = introState?.name?.trim() || 'unknown';
+      userAttributes.level = (introState?.level as string) || 'unknown';
+      userAttributes.goal = introState?.goal?.trim() || 'unknown';
+
       const targetingKey = attrs.userId || connectionId;
-      const userContext: UserContextInterface = {
+      const userContext = {
         attributes: userAttributes,
-        targetingKey: targetingKey,
+        targetingKey,
       };
 
       const flashcards = await flashcardProcessor.generateFlashcards(
@@ -143,117 +185,88 @@ wss.on('connection', (ws) => {
         ws.send(
           JSON.stringify({
             type: 'flashcards_generated',
-            flashcards: flashcards,
+            flashcards,
           })
         );
       }
-    } catch (error: unknown) {
-      // Suppress "Environment closed" errors during shutdown - they're expected
-      const err = error as { context?: string };
-      if (isShuttingDown && err?.context === 'Environment closed') {
-        console.log('Flashcard generation cancelled due to shutdown');
-      } else {
-        console.error('Error generating flashcards:', error);
+    } catch (error) {
+      if (!isShuttingDown) {
+        console.error('[Server] Error generating flashcards:', error);
       }
     }
   });
 
-  // Set up introduction-state extraction callback (runs until complete)
-  audioProcessor.setIntroductionStateCallback(async (messages) => {
+  // Set up introduction state extraction callback
+  connectionManager.setIntroductionStateCallback(async (messages) => {
     try {
       const currentState = introductionStateProcessor.getState();
-      console.log(
-        'Server - Current introduction state before update:',
-        currentState
-      );
-      console.log(
-        'Server - Is complete?',
-        introductionStateProcessor.isComplete()
-      );
-
       if (introductionStateProcessor.isComplete()) {
-        console.log(
-          'Server - Introduction state is complete, returning:',
-          currentState
-        );
         return currentState;
       }
 
       const state = await introductionStateProcessor.update(messages);
-      console.log('Server - Updated introduction state:', state);
       return state;
     } catch (error) {
-      console.error('Error generating introduction state:', error);
+      console.error('[Server] Error extracting introduction state:', error);
       return null;
     }
   });
 
+  // Start the graph for this connection
+  try {
+    await connectionManager.start();
+    console.log(`[Server] Graph started for connection ${connectionId}`);
+  } catch (error) {
+    console.error(`[Server] Failed to start graph for ${connectionId}:`, error);
+    ws.close(1011, 'Failed to start audio processing');
+    return;
+  }
+
+  // Handle incoming messages
   ws.on('message', (data) => {
     try {
       const message = JSON.parse(data.toString());
 
       if (message.type === 'audio_chunk' && message.audio_data) {
         // Process audio chunk
-        audioProcessor.addAudioChunk(message.audio_data);
+        connectionManager.addAudioChunk(message.audio_data);
       } else if (message.type === 'reset_flashcards') {
-        // Reset flashcards for new conversation
         const processor = flashcardProcessors.get(connectionId);
         if (processor) {
           processor.reset();
         }
       } else if (message.type === 'restart_conversation') {
-        // Reset conversation state, introduction state, and flashcards
-        const audioProc = audioProcessors.get(connectionId);
-        const flashcardProc = flashcardProcessors.get(connectionId);
-        const introStateProc = introductionStateProcessors.get(connectionId);
-
-        if (audioProc) {
-          audioProc.reset();
-        }
-        if (flashcardProc) {
-          flashcardProc.reset();
-        }
-        if (introStateProc) {
-          introStateProc.reset();
-        }
-
-        console.log(`Conversation restarted for connection: ${connectionId}`);
+        // Reset all state
+        connectionManager.reset();
+        flashcardProcessors.get(connectionId)?.reset();
+        introductionStateProcessors.get(connectionId)?.reset();
+        console.log(`[Server] Conversation restarted for ${connectionId}`);
       } else if (message.type === 'set_language') {
         // Handle language change
         const newLanguageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
         const attrs = connectionAttributes.get(connectionId) || {};
 
-        // Only process if language actually changed
         if (attrs.languageCode !== newLanguageCode) {
           console.log(
-            `Language change requested for ${connectionId}: ${attrs.languageCode} -> ${newLanguageCode}`
+            `[Server] Language change: ${attrs.languageCode} -> ${newLanguageCode}`
           );
 
-          // Update stored language
           attrs.languageCode = newLanguageCode;
           connectionAttributes.set(connectionId, attrs);
 
-          // Get the new language config
           const languageConfig = getLanguageConfig(newLanguageCode);
 
-          // Update all processors with new language
-          const audioProc = audioProcessors.get(connectionId);
-          const flashcardProc = flashcardProcessors.get(connectionId);
-          const introStateProc = introductionStateProcessors.get(connectionId);
-
-          if (flashcardProc) {
-            flashcardProc.setLanguage(newLanguageCode);
-          }
-          if (introStateProc) {
-            introStateProc.setLanguage(newLanguageCode);
-          }
-          if (audioProc) {
-            // Audio processor needs a new graph for the new language
-            const newGraph = getGraphForLanguage(newLanguageCode);
-            audioProc.setLanguage(newLanguageCode, newGraph);
-          }
-
-          // Send confirmation to frontend
+          // Update all processors
+          flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+          introductionStateProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+          connectionManager.setLanguage(newLanguageCode);
+
+          // Reset conversation on language change
+          connectionManager.reset();
+          flashcardProcessors.get(connectionId)?.reset();
+          introductionStateProcessors.get(connectionId)?.reset();
+
+          // Send confirmation
           ws.send(
             JSON.stringify({
               type: 'language_changed',
@@ -263,19 +276,12 @@ wss.on('connection', (ws) => {
             })
           );
 
-          console.log(`Language changed to ${languageConfig.name} for ${connectionId}`);
+          console.log(`[Server] Language changed to ${languageConfig.name}`);
         }
       } else if (message.type === 'user_context') {
-        const timezone =
-          message.timezone ||
-          (message.data && message.data.timezone) ||
-          undefined;
-        const userId =
-          message.userId || (message.data && message.data.userId) || undefined;
-        const languageCode =
-          message.languageCode ||
-          (message.data && message.data.languageCode) ||
-          undefined;
+        const timezone = message.timezone || message.data?.timezone;
+        const userId = message.userId || message.data?.userId;
+        const languageCode = message.languageCode || message.data?.languageCode;
         const currentAttrs = connectionAttributes.get(connectionId) || {};
         connectionAttributes.set(connectionId, {
           ...currentAttrs,
@@ -298,162 +304,140 @@ wss.on('connection', (ws) => {
             source: 'ui',
             timezone: attrs.timezone || '',
             languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
-            name: (introState?.name && introState.name.trim()) || 'unknown',
-            level:
-              (introState?.level && (introState.level as string)) || 'unknown',
-            goal: (introState?.goal && introState.goal.trim()) || 'unknown',
+            name: introState?.name?.trim() || 'unknown',
+            level: (introState?.level as string) || 'unknown',
+            goal: introState?.goal?.trim() || 'unknown',
           });
         } catch (err) {
-          console.error('Error recording flashcard click metric:', err);
+          console.error('[Server] Error recording flashcard click:', err);
         }
       } else {
-        console.log('Received non-audio message:', message.type);
+        console.log('[Server] Received message type:', message.type);
       }
     } catch (error) {
-      console.error('Error processing message:', error);
+      console.error('[Server] Error processing message:', error);
     }
   });
 
   ws.on('error', (error) => {
-    console.error(`WebSocket error for ${connectionId}:`, error);
-    // Don't crash - errors are handled by close event
+    console.error(`[Server] WebSocket error for ${connectionId}:`, error);
   });
 
   ws.on('close', async () => {
-    console.log(`WebSocket connection closed: ${connectionId}`);
+    console.log(`[Server] WebSocket closed: ${connectionId}`);
 
-    // Clean up audio processor
-    const processor = audioProcessors.get(connectionId);
-    if (processor) {
+    // Clean up connection manager
+    const manager = connectionManagers.get(connectionId);
+    if (manager) {
       try {
-        await processor.destroy();
+        await manager.destroy();
       } catch (error) {
-        console.error(
-          `Error destroying audio processor for ${connectionId}:`,
-          error
-        );
-        // Continue with cleanup even if destroy fails
+        console.error(`[Server] Error destroying connection manager:`, error);
       }
-      audioProcessors.delete(connectionId);
+      connectionManagers.delete(connectionId);
     }
 
-    // Clean up processors
+    // Clean up other processors
     flashcardProcessors.delete(connectionId);
     introductionStateProcessors.delete(connectionId);
     connectionAttributes.delete(connectionId);
   });
 });
 
-// API endpoint for ANKI export
-app.post('/api/export-anki', async (req, res) => {
-  try {
-    const { flashcards, deckName, languageCode } = req.body;
-
-    if (!flashcards || !Array.isArray(flashcards)) {
-      return res.status(400).json({ error: 'Invalid flashcards data' });
-    }
+// ============================================================
+// API Endpoints
+// ============================================================
 
-    // Get language config for deck naming
-    const langCode = languageCode || DEFAULT_LANGUAGE_CODE;
-    const languageConfig = getLanguageConfig(langCode);
-    const defaultDeckName = `Aprendemo ${languageConfig.name} Cards`;
-
-    const exporter = new AnkiExporter();
-    const ankiBuffer = await exporter.exportFlashcards(
-      flashcards,
-      deckName || defaultDeckName
-    );
-
-    // Set headers for file download
-    const filename = `${deckName || `aprendemo_${langCode}_cards`}.apkg`;
-    res.setHeader('Content-Type', 'application/octet-stream');
-    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
-    res.setHeader('Content-Length', ankiBuffer.length);
-
-    // Send the file
-    res.send(ankiBuffer);
-    return;
-  } catch (error) {
-    console.error('Error exporting to ANKI:', error);
-    res.status(500).json({ error: 'Failed to export flashcards' });
-    return;
-  }
-});
+// ANKI export endpoint - temporarily disabled
+// app.post('/api/export-anki', async (req, res) => {
+//   ...
+// });
 
-// API endpoint to get supported languages
+// Languages endpoint
 app.get('/api/languages', (_req, res) => {
   try {
     const languages = getLanguageOptions();
     res.json({ languages, defaultLanguage: DEFAULT_LANGUAGE_CODE });
   } catch (error) {
-    console.error('Error getting languages:', error);
+    console.error('[Server] Error getting languages:', error);
     res.status(500).json({ error: 'Failed to get languages' });
   }
 });
 
-// Serve static frontend files
-// When running from dist/backend/server.js, go up two levels to project root
-// When running from backend/server.ts (dev mode), go up one level to project root
+// ============================================================
+// Static Files
+// ============================================================
+
 const frontendPath = path.join(__dirname, '../../frontend');
 const devFrontendPath = path.join(__dirname, '../frontend');
 const staticPath = path.resolve(frontendPath);
 const devStaticPath = path.resolve(devFrontendPath);
-// Use the path that exists
 const finalStaticPath = existsSync(devStaticPath) ? devStaticPath : staticPath;
 app.use(express.static(finalStaticPath));
 
-server.listen(PORT, () => {
-  console.log(`Server running on port ${PORT}`);
-});
+// ============================================================
+// Server Startup
+// ============================================================
 
-// Graceful shutdown - prevent multiple calls
-let isShuttingDown = false;
-
-async function gracefulShutdown() {
-  if (isShuttingDown) {
-    return;
+async function startServer(): Promise<void> {
+  try {
+    await initializeGraph();
+    server.listen(PORT, () => {
+      console.log(`[Server] Running on port ${PORT}`);
+      console.log(`[Server] Using Inworld Runtime 0.9 with AssemblyAI STT`);
+    });
+  } catch (error) {
+    console.error('[Server] Failed to start:', error);
+    process.exit(1);
   }
+}
+
+startServer();
+
+// ============================================================
+// Graceful Shutdown
+// ============================================================
+
+async function gracefulShutdown(): Promise<void> {
+  if (isShuttingDown) return;
   isShuttingDown = true;
 
-  console.log('Shutting down gracefully...');
+  console.log('[Server] Shutting down gracefully...');
 
   try {
-    // Close all WebSocket connections immediately
-    console.log(`Closing ${wss.clients.size} WebSocket connections...`);
+    // Close all WebSocket connections
+    console.log(`[Server] Closing ${wss.clients.size} WebSocket connections...`);
     wss.clients.forEach((ws) => {
       if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
         ws.close();
       }
     });
 
-    // Close WebSocket server (non-blocking)
     wss.close();
 
-    // Clean up processors (fire and forget - don't wait)
-    for (const processor of audioProcessors.values()) {
-      processor.destroy().catch(() => {
-        // Ignore errors during shutdown
-      });
+    // Clean up connection managers
+    for (const manager of connectionManagers.values()) {
+      manager.destroy().catch(() => {});
+    }
+
+    // Clean up graph wrapper
+    if (graphWrapper) {
+      await graphWrapper.destroy();
     }
 
-    // Close HTTP server (non-blocking)
     server.close(() => {
-      console.log('HTTP server closed');
+      console.log('[Server] HTTP server closed');
     });
 
-    // Stop Inworld Runtime (fire and forget - don't wait)
     stopInworldRuntime()
-      .then(() => console.log('Inworld Runtime stopped'))
-      .catch(() => {
-        // Ignore errors during shutdown
-      });
+      .then(() => console.log('[Server] Inworld Runtime stopped'))
+      .catch(() => {});
 
-    console.log('Shutdown complete');
+    console.log('[Server] Shutdown complete');
   } catch {
     // Ignore errors during shutdown
   }
 
-  // Exit immediately - don't wait for anything
   process.exitCode = 0;
   process.exit(0);
 }
diff --git a/backend/types/index.ts b/backend/types/index.ts
new file mode 100644
index 0000000..90c7965
--- /dev/null
+++ b/backend/types/index.ts
@@ -0,0 +1,81 @@
+/**
+ * Types for the 0.9 long-running graph architecture
+ */
+
+import { WebSocket } from 'ws';
+import type { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager.js';
+import type { GraphOutputStream } from '@inworld/runtime/graph';
+import type { IntroductionState } from '../helpers/introduction-state-processor.js';
+
+/**
+ * Chat message in conversation history
+ */
+export interface ChatMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp?: string;
+}
+
+/**
+ * Connection state for a session
+ * This is the central state object that graph nodes read from
+ */
+export interface State {
+  interactionId: string;
+  messages: ChatMessage[];
+  voiceId?: string;
+  // Language learning specific
+  userName: string;
+  targetLanguage: string;
+  languageCode: string;
+  introductionState: IntroductionState;
+  // Output modalities (for graph routing)
+  output_modalities: ('text' | 'audio')[];
+}
+
+/**
+ * Connection object for a WebSocket session
+ */
+export interface Connection {
+  ws: WebSocket;
+  state: State;
+  unloaded?: true;
+  multimodalStreamManager?: MultimodalStreamManager;
+  currentAudioGraphExecution?: Promise<void>;
+  currentAudioExecutionStream?: GraphOutputStream;
+  onSpeechDetected?: (interactionId: string) => void;
+  onPartialTranscript?: (text: string, interactionId: string) => void;
+}
+
+/**
+ * Map of session IDs to connections
+ */
+export type ConnectionsMap = { [sessionId: string]: Connection };
+
+/**
+ * Text input passed between graph nodes
+ */
+export interface TextInput {
+  sessionId: string;
+  text: string;
+  interactionId: string;
+  voiceId?: string;
+}
+
+/**
+ * Interaction info extracted from STT
+ */
+export interface InteractionInfo {
+  sessionId: string;
+  interactionId: string;
+  text: string;
+  interactionComplete: boolean;
+}
+
+/**
+ * Config constants
+ */
+export const INPUT_SAMPLE_RATE = 16000;
+// Inworld TTS typically outputs at 22050Hz
+export const TTS_SAMPLE_RATE = 22050;
diff --git a/backend/types/settings.ts b/backend/types/settings.ts
new file mode 100644
index 0000000..26b0184
--- /dev/null
+++ b/backend/types/settings.ts
@@ -0,0 +1,47 @@
+/**
+ * Maps eagerness levels to AssemblyAI turn detection settings
+ * Based on AssemblyAI's recommended configurations for different use cases
+ */
+
+export interface AssemblyAITurnDetectionSettings {
+  endOfTurnConfidenceThreshold: number;
+  minEndOfTurnSilenceWhenConfident: number;
+  maxTurnSilence: number;
+  description: string;
+}
+
+/**
+ * Get AssemblyAI turn detection settings for a given eagerness level
+ * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
+ * @returns AssemblyAI turn detection settings including threshold values and description
+ */
+export function getAssemblyAISettingsForEagerness(
+  eagerness: 'low' | 'medium' | 'high' = 'medium'
+): AssemblyAITurnDetectionSettings {
+  switch (eagerness) {
+    case 'high': // Aggressive - VERY responsive
+      return {
+        endOfTurnConfidenceThreshold: 0.4,
+        minEndOfTurnSilenceWhenConfident: 160,
+        maxTurnSilence: 320,
+        description:
+          'Aggressive - VERY quick responses, ideal for rapid Q&A (Agent Assist, IVR)',
+      };
+    case 'medium': // Balanced (default) - good for language learning
+      return {
+        endOfTurnConfidenceThreshold: 0.4,
+        minEndOfTurnSilenceWhenConfident: 400,
+        maxTurnSilence: 1280,
+        description:
+          'Balanced - Natural conversation flow (Customer Support, Tech Support)',
+      };
+    case 'low': // Conservative - VERY patient
+      return {
+        endOfTurnConfidenceThreshold: 0.7,
+        minEndOfTurnSilenceWhenConfident: 800,
+        maxTurnSilence: 3000,
+        description:
+          'Conservative - VERY patient, allows long thinking pauses (Complex inquiries)',
+      };
+  }
+}
diff --git a/flashcard-graph.json b/flashcard-graph.json
deleted file mode 100644
index 80be8e4..0000000
--- a/flashcard-graph.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
-  "schema_version": "1.2.0",
-  "main": {
-    "id": "flashcard-generation-graph-es",
-    "nodes": [
-      {
-        "type": "FlashcardPromptBuilderNodeType",
-        "id": "flashcard-prompt-builder",
-        "execution_config": {
-          "type": "NodeExecutionConfig",
-          "properties": {
-            "report_to_client": false
-          }
-        }
-      },
-      {
-        "type": "TextToChatRequestNodeType",
-        "id": "text-to-chat-request",
-        "execution_config": {
-          "type": "NodeExecutionConfig",
-          "properties": {
-            "report_to_client": false
-          }
-        }
-      },
-      {
-        "id": "llm_node",
-        "type": "LLMChatNode",
-        "execution_config": {
-          "type": "LLMChatNodeExecutionConfig",
-          "properties": {
-            "llm_component_id": "llm_node_llm_component",
-            "text_generation_config": {
-              "max_new_tokens": 2500,
-              "max_prompt_length": 100,
-              "repetition_penalty": 1,
-              "top_p": 1,
-              "temperature": 1,
-              "frequency_penalty": 0,
-              "presence_penalty": 0
-            },
-            "stream": false,
-            "report_to_client": false,
-            "response_format": "text"
-          }
-        }
-      },
-      {
-        "type": "FlashcardParserNodeType",
-        "id": "flashcard-parser",
-        "execution_config": {
-          "type": "NodeExecutionConfig",
-          "properties": {
-            "report_to_client": false
-          }
-        }
-      }
-    ],
-    "edges": [
-      {
-        "from_node": "flashcard-prompt-builder",
-        "to_node": "text-to-chat-request"
-      },
-      {
-        "from_node": "text-to-chat-request",
-        "to_node": "llm_node"
-      },
-      {
-        "from_node": "llm_node",
-        "to_node": "flashcard-parser"
-      }
-    ],
-    "end_nodes": [
-      "flashcard-parser"
-    ],
-    "start_nodes": [
-      "flashcard-prompt-builder"
-    ]
-  },
-  "components": [
-    {
-      "id": "llm_node_llm_component",
-      "type": "LLMInterface",
-      "creation_config": {
-        "type": "RemoteLLMConfig",
-        "properties": {
-          "provider": "openai",
-          "model_name": "gpt-5",
-          "default_config": {},
-          "api_key": "{{INWORLD_API_KEY}}"
-        }
-      }
-    }
-  ]
-}
\ No newline at end of file
diff --git a/frontend/js/audio-player.js b/frontend/js/audio-player.js
index 8ee152e..fcd34b2 100644
--- a/frontend/js/audio-player.js
+++ b/frontend/js/audio-player.js
@@ -55,7 +55,7 @@ export class AudioPlayer {
     }
   }
 
-  async addAudioStream(base64Audio, sampleRate = 16000, isLastChunk = false) {
+  async addAudioStream(base64Audio, sampleRate = 16000, isLastChunk = false, audioFormat = 'int16') {
     if (!base64Audio || base64Audio.length === 0) {
       console.warn('Empty audio data received');
       return;
@@ -110,7 +110,8 @@ export class AudioPlayer {
       // Create audio buffer from the decoded data
       const audioBuffer = await this.createAudioBuffer(
         bytes.buffer,
-        sampleRate
+        sampleRate,
+        audioFormat
       );
 
       // Queue the audio buffer for playback
@@ -131,24 +132,51 @@ export class AudioPlayer {
     }
   }
 
-  async createAudioBuffer(arrayBuffer, sampleRate) {
+  async createAudioBuffer(arrayBuffer, sampleRate, audioFormat = 'int16') {
     try {
-      // We know the backend sends raw PCM Int16 data, so skip decode attempt
-      // and directly process as PCM for faster playback
-      const int16Array = new Int16Array(arrayBuffer);
-      const audioBuffer = this.audioContext.createBuffer(
-        1,
-        int16Array.length,
-        sampleRate
-      );
-      const channelData = audioBuffer.getChannelData(0);
+      let channelData;
+      let numSamples;
+
+      console.log(`[AudioPlayer] createAudioBuffer: format=${audioFormat}, byteLength=${arrayBuffer.byteLength}, sampleRate=${sampleRate}`);
+
+      if (audioFormat === 'float32') {
+        // Float32 PCM - bytes are IEEE 754 Float32 representation
+        // 4 bytes per sample, values already in [-1.0, 1.0] range
+        const float32Array = new Float32Array(arrayBuffer);
+        numSamples = float32Array.length;
+        console.log(`[AudioPlayer] Float32 samples: ${numSamples}, first 3 values: [${Array.from(float32Array.slice(0, 3)).map(v => v.toFixed(4)).join(', ')}]`);
+
+        const audioBuffer = this.audioContext.createBuffer(
+          1,
+          numSamples,
+          sampleRate
+        );
+        channelData = audioBuffer.getChannelData(0);
 
-      // Convert Int16 to Float32 and normalize
-      for (let i = 0; i < int16Array.length; i++) {
-        channelData[i] = int16Array[i] / 32768.0;
-      }
+        for (let i = 0; i < numSamples; i++) {
+          channelData[i] = float32Array[i];
+        }
 
-      return audioBuffer;
+        return audioBuffer;
+      } else {
+        // Int16 PCM format - convert to Float32
+        const int16Array = new Int16Array(arrayBuffer);
+        numSamples = int16Array.length;
+        console.log(`[AudioPlayer] Int16 samples: ${numSamples}`);
+
+        const audioBuffer = this.audioContext.createBuffer(
+          1,
+          numSamples,
+          sampleRate
+        );
+        channelData = audioBuffer.getChannelData(0);
+
+        for (let i = 0; i < numSamples; i++) {
+          channelData[i] = int16Array[i] / 32768.0;
+        }
+
+        return audioBuffer;
+      }
     } catch (error) {
       console.error('Error creating audio buffer:', error);
       throw error;
diff --git a/frontend/js/chat-ui.js b/frontend/js/chat-ui.js
index 369621b..3ebfd61 100644
--- a/frontend/js/chat-ui.js
+++ b/frontend/js/chat-ui.js
@@ -1,3 +1,5 @@
+import { translator } from './translator.js';
+
 export class ChatUI {
   constructor() {
     this.messagesContainer = document.getElementById('messages');
@@ -5,6 +7,111 @@ export class ChatUI {
     this.typewriterTimers = new Map(); // Track active typewriter effects
     this.typewriterSpeed = 25; // milliseconds per character
     this.llmTypewriterCallback = null; // Callback for when LLM typewriter completes
+    
+    // Translation tooltip
+    this.translationTooltip = this._createTranslationTooltip();
+    this.activeHoverElement = null;
+    this.hoverTimeout = null;
+    this.hideTimeout = null;
+  }
+
+  _createTranslationTooltip() {
+    const tooltip = document.createElement('div');
+    tooltip.className = 'translation-tooltip';
+    tooltip.innerHTML = `
+      <div class="translation-content">
+        <span class="translation-text"></span>
+      </div>
+      <div class="translation-loading">
+        <span></span><span></span><span></span>
+      </div>
+    `;
+    document.body.appendChild(tooltip);
+    
+    // Keep tooltip visible when hovering over it
+    tooltip.addEventListener('mouseenter', () => {
+      if (this.hideTimeout) {
+        clearTimeout(this.hideTimeout);
+        this.hideTimeout = null;
+      }
+    });
+    
+    tooltip.addEventListener('mouseleave', () => {
+      this._hideTooltip();
+    });
+    
+    return tooltip;
+  }
+
+  _showTooltip(element, text) {
+    const rect = element.getBoundingClientRect();
+    const tooltip = this.translationTooltip;
+    
+    // Position tooltip above the message
+    tooltip.style.left = `${rect.left + window.scrollX}px`;
+    tooltip.style.top = `${rect.top + window.scrollY - 8}px`;
+    tooltip.style.maxWidth = `${Math.min(rect.width + 40, 400)}px`;
+    
+    // Show loading state
+    tooltip.classList.add('visible', 'loading');
+    tooltip.querySelector('.translation-text').textContent = '';
+    
+    // Fetch translation
+    translator.translate(text, 'en', 'auto')
+      .then(translation => {
+        if (this.activeHoverElement === element) {
+          tooltip.querySelector('.translation-text').textContent = translation;
+          tooltip.classList.remove('loading');
+          
+          // Reposition after content loads (in case size changed)
+          requestAnimationFrame(() => {
+            const tooltipRect = tooltip.getBoundingClientRect();
+            tooltip.style.top = `${rect.top + window.scrollY - tooltipRect.height - 8}px`;
+          });
+        }
+      })
+      .catch(error => {
+        console.error('[ChatUI] Translation failed:', error);
+        if (this.activeHoverElement === element) {
+          tooltip.querySelector('.translation-text').textContent = 'Translation unavailable';
+          tooltip.classList.remove('loading');
+        }
+      });
+  }
+
+  _hideTooltip() {
+    this.translationTooltip.classList.remove('visible', 'loading');
+    this.activeHoverElement = null;
+  }
+
+  _setupTranslationHover(element) {
+    element.addEventListener('mouseenter', () => {
+      if (this.hideTimeout) {
+        clearTimeout(this.hideTimeout);
+        this.hideTimeout = null;
+      }
+      
+      // Small delay before showing tooltip to avoid flickering
+      this.hoverTimeout = setTimeout(() => {
+        this.activeHoverElement = element;
+        const text = element.textContent.replace('▊', '').trim(); // Remove cursor
+        if (text) {
+          this._showTooltip(element, text);
+        }
+      }, 300);
+    });
+
+    element.addEventListener('mouseleave', () => {
+      if (this.hoverTimeout) {
+        clearTimeout(this.hoverTimeout);
+        this.hoverTimeout = null;
+      }
+      
+      // Delay hiding to allow moving to tooltip
+      this.hideTimeout = setTimeout(() => {
+        this._hideTooltip();
+      }, 150);
+    });
   }
 
   render(
@@ -149,6 +256,12 @@ export class ChatUI {
     const div = document.createElement('div');
     div.className = `message ${message.role}`;
     div.textContent = message.content;
+    
+    // Add translation hover for teacher (LLM) messages
+    if (message.role === 'teacher') {
+      this._setupTranslationHover(div);
+    }
+    
     return div;
   }
 
@@ -166,6 +279,9 @@ export class ChatUI {
     cursor.textContent = '▊';
     div.appendChild(cursor);
 
+    // Add translation hover for streaming teacher messages too
+    this._setupTranslationHover(div);
+
     return div;
   }
 
diff --git a/frontend/js/main.js b/frontend/js/main.js
index cf3f1d8..4cfcc8b 100644
--- a/frontend/js/main.js
+++ b/frontend/js/main.js
@@ -274,6 +274,15 @@ class App {
       this.render();
     });
 
+    this.wsClient.on('partial_transcript', (data) => {
+      // Update the transcript in real-time as AssemblyAI processes speech
+      if (data.text) {
+        this.state.currentTranscript = data.text;
+        this.state.speechDetected = true;
+        this.render();
+      }
+    });
+
     this.wsClient.on('speech_ended', (data) => {
       // VAD stopped detecting speech - clear the real-time transcript bubble
       console.log(
@@ -828,9 +837,9 @@ class App {
     try {
       if (data.audio && data.audio.length > 0) {
         console.log(
-          `Received audio stream: ${data.audio.length} bytes at ${data.sampleRate}Hz${data.text ? ` with text: "${data.text}"` : ''}`
+          `Received audio stream: ${data.audio.length} bytes at ${data.sampleRate}Hz [format:${data.audioFormat}]${data.text ? ` with text: "${data.text}"` : ''}`
         );
-        await this.audioPlayer.addAudioStream(data.audio, data.sampleRate);
+        await this.audioPlayer.addAudioStream(data.audio, data.sampleRate, false, data.audioFormat);
       }
     } catch (error) {
       console.error('Error handling audio stream:', error);
diff --git a/frontend/js/translator.js b/frontend/js/translator.js
new file mode 100644
index 0000000..5045f02
--- /dev/null
+++ b/frontend/js/translator.js
@@ -0,0 +1,90 @@
+/**
+ * Translation service using Google's free translation endpoint
+ * No authentication required
+ */
+export class Translator {
+  constructor() {
+    this.cache = new Map();
+    this.pendingRequests = new Map();
+  }
+
+  /**
+   * Translate text to target language using Google's free endpoint
+   * @param {string} text - Text to translate
+   * @param {string} targetLang - Target language code (default: 'en')
+   * @param {string} sourceLang - Source language code (default: 'auto' for auto-detect)
+   * @returns {Promise<string>} - Translated text
+   */
+  async translate(text, targetLang = 'en', sourceLang = 'auto') {
+    if (!text || !text.trim()) {
+      return '';
+    }
+
+    const cacheKey = `${sourceLang}:${targetLang}:${text}`;
+    
+    // Check cache first
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    // Check if there's already a pending request for this text
+    if (this.pendingRequests.has(cacheKey)) {
+      return this.pendingRequests.get(cacheKey);
+    }
+
+    // Create the translation request
+    const requestPromise = this._fetchTranslation(text, targetLang, sourceLang)
+      .then(translation => {
+        this.cache.set(cacheKey, translation);
+        this.pendingRequests.delete(cacheKey);
+        return translation;
+      })
+      .catch(error => {
+        this.pendingRequests.delete(cacheKey);
+        throw error;
+      });
+
+    this.pendingRequests.set(cacheKey, requestPromise);
+    return requestPromise;
+  }
+
+  async _fetchTranslation(text, targetLang, sourceLang) {
+    const encodedText = encodeURIComponent(text);
+    const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${sourceLang}&tl=${targetLang}&dt=t&q=${encodedText}`;
+
+    try {
+      const response = await fetch(url);
+      
+      if (!response.ok) {
+        throw new Error(`Translation failed: ${response.status}`);
+      }
+
+      const data = await response.json();
+      
+      // Google's response format: [[["translated text", "original text", ...], ...], ...]
+      // We need to concatenate all translated segments
+      if (data && data[0]) {
+        const translatedParts = data[0]
+          .filter(part => part && part[0])
+          .map(part => part[0]);
+        return translatedParts.join('');
+      }
+
+      throw new Error('Invalid translation response format');
+    } catch (error) {
+      console.error('[Translator] Translation error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Clear the translation cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+// Singleton instance
+export const translator = new Translator();
+
diff --git a/frontend/js/websocket-client.js b/frontend/js/websocket-client.js
index a07ff1a..200d0da 100644
--- a/frontend/js/websocket-client.js
+++ b/frontend/js/websocket-client.js
@@ -154,6 +154,14 @@ export class WebSocketClient {
         this.emit('speech_ended', message.data);
         break;
 
+      case 'partial_transcript':
+        this.emit('partial_transcript', {
+          text: message.text,
+          interactionId: message.interactionId,
+          timestamp: message.timestamp,
+        });
+        break;
+
       case 'llm_response_chunk':
         this.emit('llm_response_chunk', {
           text: message.text,
@@ -171,6 +179,7 @@ export class WebSocketClient {
       case 'audio_stream':
         this.emit('audio_stream', {
           audio: message.audio,
+          audioFormat: message.audioFormat || 'int16',
           sampleRate: message.sampleRate,
           timestamp: message.timestamp,
         });
diff --git a/frontend/styles/main.css b/frontend/styles/main.css
index 00c0f6e..066e468 100644
--- a/frontend/styles/main.css
+++ b/frontend/styles/main.css
@@ -576,4 +576,108 @@ body {
 .messages::-webkit-scrollbar-thumb:hover,
 .flashcards-grid::-webkit-scrollbar-thumb:hover {
     background: #9ca3af;
+}
+
+/* Translation Tooltip */
+.translation-tooltip {
+    position: absolute;
+    z-index: 1000;
+    background: #1a1a1a;
+    color: #ffffff;
+    padding: 10px 14px;
+    border-radius: 8px;
+    font-size: 14px;
+    line-height: 1.4;
+    max-width: 400px;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.25);
+    opacity: 0;
+    visibility: hidden;
+    transform: translateY(4px);
+    transition: opacity 0.2s ease, transform 0.2s ease, visibility 0.2s;
+    pointer-events: none;
+}
+
+.translation-tooltip.visible {
+    opacity: 1;
+    visibility: visible;
+    transform: translateY(0);
+    pointer-events: auto;
+}
+
+.translation-tooltip::after {
+    content: '';
+    position: absolute;
+    bottom: -6px;
+    left: 20px;
+    width: 12px;
+    height: 12px;
+    background: #1a1a1a;
+    transform: rotate(45deg);
+    border-radius: 0 0 2px 0;
+}
+
+.translation-content {
+    display: block;
+}
+
+.translation-text {
+    display: block;
+    word-wrap: break-word;
+}
+
+.translation-loading {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    padding: 4px 0;
+}
+
+.translation-tooltip.loading .translation-loading {
+    display: flex;
+}
+
+.translation-tooltip.loading .translation-content {
+    display: none;
+}
+
+.translation-loading span {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: rgba(255, 255, 255, 0.7);
+    animation: translation-dot 1.2s ease-in-out infinite;
+}
+
+.translation-loading span:nth-child(1) {
+    animation-delay: 0s;
+}
+
+.translation-loading span:nth-child(2) {
+    animation-delay: 0.15s;
+}
+
+.translation-loading span:nth-child(3) {
+    animation-delay: 0.3s;
+}
+
+@keyframes translation-dot {
+    0%, 60%, 100% {
+        opacity: 0.4;
+        transform: scale(0.8);
+    }
+    30% {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+/* Make teacher messages show a subtle cursor hint for translation */
+.message.teacher {
+    cursor: help;
+    transition: background-color 0.15s ease;
+}
+
+.message.teacher:hover {
+    background: #e9eaec;
 }
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 7bdb6aa..d94e982 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "MIT",
       "dependencies": {
-        "@inworld/runtime": "^0.8.0",
+        "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
         "anki-apkg-export": "^4.0.3",
         "dotenv": "^17.2.1",
         "express": "^4.19.2",
@@ -696,329 +696,6 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
-    "node_modules/@fastify/accept-negotiator": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@fastify/accept-negotiator/-/accept-negotiator-2.0.1.tgz",
-      "integrity": "sha512-/c/TW2bO/v9JeEgoD/g1G5GxGeCF1Hafdf79WPmUlgYiBXummY0oX3VVq4yFkKKVBKDNlaDUYoab7g38RpPqCQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/@fastify/ajv-compiler": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/@fastify/ajv-compiler/-/ajv-compiler-4.0.5.tgz",
-      "integrity": "sha512-KoWKW+MhvfTRWL4qrhUwAAZoaChluo0m0vbiJlGMt2GXvL4LVPQEjt8kSpHI3IBq5Rez8fg+XeH3cneztq+C7A==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^8.12.0",
-        "ajv-formats": "^3.0.1",
-        "fast-uri": "^3.0.0"
-      }
-    },
-    "node_modules/@fastify/cors": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/@fastify/cors/-/cors-10.1.0.tgz",
-      "integrity": "sha512-MZyBCBJtII60CU9Xme/iE4aEy8G7QpzGR8zkdXZkDFt7ElEMachbE61tfhAG/bvSaULlqlf0huMT12T7iqEmdQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "fastify-plugin": "^5.0.0",
-        "mnemonist": "0.40.0"
-      }
-    },
-    "node_modules/@fastify/error": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/@fastify/error/-/error-4.2.0.tgz",
-      "integrity": "sha512-RSo3sVDXfHskiBZKBPRgnQTtIqpi/7zhJOEmAxCiBcM7d0uwdGdxLlsCaLzGs8v8NnxIRlfG0N51p5yFaOentQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/@fastify/fast-json-stringify-compiler": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/@fastify/fast-json-stringify-compiler/-/fast-json-stringify-compiler-5.0.3.tgz",
-      "integrity": "sha512-uik7yYHkLr6fxd8hJSZ8c+xF4WafPK+XzneQDPU+D10r5X19GW8lJcom2YijX2+qtFF1ENJlHXKFM9ouXNJYgQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "fast-json-stringify": "^6.0.0"
-      }
-    },
-    "node_modules/@fastify/forwarded": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/@fastify/forwarded/-/forwarded-3.0.1.tgz",
-      "integrity": "sha512-JqDochHFqXs3C3Ml3gOY58zM7OqO9ENqPo0UqAjAjH8L01fRZqwX9iLeX34//kiJubF7r2ZQHtBRU36vONbLlw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/@fastify/merge-json-schemas": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/@fastify/merge-json-schemas/-/merge-json-schemas-0.2.1.tgz",
-      "integrity": "sha512-OA3KGBCy6KtIvLf8DINC5880o5iBlDX4SxzLQS8HorJAbqluzLRn80UXU0bxZn7UOFhFgpRJDasfwn9nG4FG4A==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "dequal": "^2.0.3"
-      }
-    },
-    "node_modules/@fastify/proxy-addr": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/@fastify/proxy-addr/-/proxy-addr-5.1.0.tgz",
-      "integrity": "sha512-INS+6gh91cLUjB+PVHfu1UqcB76Sqtpyp7bnL+FYojhjygvOPA9ctiD/JDKsyD9Xgu4hUhCSJBPig/w7duNajw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/forwarded": "^3.0.0",
-        "ipaddr.js": "^2.1.0"
-      }
-    },
-    "node_modules/@fastify/proxy-addr/node_modules/ipaddr.js": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz",
-      "integrity": "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@fastify/send": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@fastify/send/-/send-4.1.0.tgz",
-      "integrity": "sha512-TMYeQLCBSy2TOFmV95hQWkiTYgC/SEx7vMdV+wnZVX4tt8VBLKzmH8vV9OzJehV0+XBfg+WxPMt5wp+JBUKsVw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@lukeed/ms": "^2.0.2",
-        "escape-html": "~1.0.3",
-        "fast-decode-uri-component": "^1.0.1",
-        "http-errors": "^2.0.0",
-        "mime": "^3"
-      }
-    },
-    "node_modules/@fastify/send/node_modules/mime": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz",
-      "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==",
-      "license": "MIT",
-      "bin": {
-        "mime": "cli.js"
-      },
-      "engines": {
-        "node": ">=10.0.0"
-      }
-    },
-    "node_modules/@fastify/static": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/@fastify/static/-/static-8.3.0.tgz",
-      "integrity": "sha512-yKxviR5PH1OKNnisIzZKmgZSus0r2OZb8qCSbqmw34aolT4g3UlzYfeBRym+HJ1J471CR8e2ldNub4PubD1coA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/accept-negotiator": "^2.0.0",
-        "@fastify/send": "^4.0.0",
-        "content-disposition": "^0.5.4",
-        "fastify-plugin": "^5.0.0",
-        "fastq": "^1.17.1",
-        "glob": "^11.0.0"
-      }
-    },
-    "node_modules/@fastify/swagger": {
-      "version": "9.6.1",
-      "resolved": "https://registry.npmjs.org/@fastify/swagger/-/swagger-9.6.1.tgz",
-      "integrity": "sha512-fKlpJqFMWoi4H3EdUkDaMteEYRCfQMEkK0HJJ0eaf4aRlKd8cbq0pVkOfXDXmtvMTXYcnx3E+l023eFDBsA1HA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "fastify-plugin": "^5.0.0",
-        "json-schema-resolver": "^3.0.0",
-        "openapi-types": "^12.1.3",
-        "rfdc": "^1.3.1",
-        "yaml": "^2.4.2"
-      }
-    },
-    "node_modules/@fastify/swagger-ui": {
-      "version": "5.2.3",
-      "resolved": "https://registry.npmjs.org/@fastify/swagger-ui/-/swagger-ui-5.2.3.tgz",
-      "integrity": "sha512-e7ivEJi9EpFcxTONqICx4llbpB2jmlI+LI1NQ/mR7QGQnyDOqZybPK572zJtcdHZW4YyYTBHcP3a03f1pOh0SA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/static": "^8.0.0",
-        "fastify-plugin": "^5.0.0",
-        "openapi-types": "^12.1.3",
-        "rfdc": "^1.3.1",
-        "yaml": "^2.4.1"
-      }
-    },
-    "node_modules/@grpc/grpc-js": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.14.1.tgz",
-      "integrity": "sha512-sPxgEWtPUR3EnRJCEtbGZG2iX8LQDUls2wUS3o27jg07KqJFMq6YDeWvMo1wfpmy3rqRdS0rivpLwhqQtEyCuQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@grpc/proto-loader": "^0.8.0",
-        "@js-sdsl/ordered-map": "^4.4.2"
-      },
-      "engines": {
-        "node": ">=12.10.0"
-      }
-    },
-    "node_modules/@grpc/grpc-js/node_modules/@grpc/proto-loader": {
-      "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.8.0.tgz",
-      "integrity": "sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "lodash.camelcase": "^4.3.0",
-        "long": "^5.0.0",
-        "protobufjs": "^7.5.3",
-        "yargs": "^17.7.2"
-      },
-      "bin": {
-        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/@grpc/proto-loader": {
-      "version": "0.7.15",
-      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz",
-      "integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "lodash.camelcase": "^4.3.0",
-        "long": "^5.0.0",
-        "protobufjs": "^7.2.5",
-        "yargs": "^17.7.2"
-      },
-      "bin": {
-        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/@grpc/reflection": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@grpc/reflection/-/reflection-1.0.4.tgz",
-      "integrity": "sha512-znA8v4AviOD3OPOxy11pxrtP8k8DanpefeTymS8iGW1fVr1U2cHuzfhYqDPHnVNDf4qvF9E25KtSihPy2DBWfQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@grpc/proto-loader": "^0.7.13",
-        "protobufjs": "^7.2.5"
-      },
-      "peerDependencies": {
-        "@grpc/grpc-js": "^1.8.21"
-      }
-    },
     "node_modules/@humanfs/core": {
       "version": "0.19.1",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
@@ -1071,118 +748,34 @@
         "url": "https://github.com/sponsors/nzakas"
       }
     },
-    "node_modules/@inworld/graph-server": {
-      "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/@inworld/graph-server/-/graph-server-0.8.0.tgz",
-      "integrity": "sha512-mwAwgIPF23RbWECNfiAcugtMFQ1ronkRu3LMoqJN7fw6EKq3npQ2lJrYdAS7WI0aJbEIWbJ3/vio17z6TP5WLQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/cors": "^10.0.1",
-        "@fastify/static": "^8.0.2",
-        "@fastify/swagger": "^9.4.0",
-        "@fastify/swagger-ui": "^5.2.0",
-        "@grpc/grpc-js": "^1.12.4",
-        "@grpc/proto-loader": "^0.7.13",
-        "@grpc/reflection": "^1.0.4",
-        "fastify": "^5.2.0",
-        "protobufjs": "^7.4.0"
-      }
-    },
     "node_modules/@inworld/runtime": {
-      "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/@inworld/runtime/-/runtime-0.8.0.tgz",
-      "integrity": "sha512-bSOydjXGiuSTm8BZ1t/dsUOK7l/WCseHjNRCMdHUFkevDzbGXHPaf7jQEPM3r4c4nyRiVabjHpi2zvLSCa+jWw==",
+      "version": "0.9.0-rc.13",
+      "resolved": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+      "integrity": "sha512-6C/aND5PqOVzujwoS0rvUR963VxJ+MO0X+IZg9WpjrxBbuFag7fXay5yyamH0cKoTvmaTT2s8fca8pK0zQ0CYg==",
       "hasInstallScript": true,
       "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
       "dependencies": {
-        "@inworld/graph-server": "0.8.0",
         "@types/lodash.snakecase": "^4.1.9",
+        "@types/protobufjs": "^6.0.0",
+        "@zod/core": "^0.11.6",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "assemblyai": "^4.17.0",
+        "chalk": "^4.1.2",
         "decompress": "^4.2.1",
         "decompress-targz": "^4.1.1",
         "decompress-unzip": "^4.0.1",
-        "dotenv": "^16.4.7",
         "groq-sdk": "^0.33.0",
-        "koffi": "^2.10.1",
         "lodash.snakecase": "^4.1.1",
         "node-record-lpcm16": "^1.0.1",
-        "uuid": "^11.1.0"
+        "protobufjs": "^7.5.4",
+        "uuid": "^11.1.0",
+        "zod-to-json-schema": "^3.25.0"
       },
       "engines": {
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@inworld/runtime/node_modules/dotenv": {
-      "version": "16.6.1",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
-      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://dotenvx.com"
-      }
-    },
-    "node_modules/@isaacs/balanced-match": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz",
-      "integrity": "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/@isaacs/brace-expansion": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.0.tgz",
-      "integrity": "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==",
-      "license": "MIT",
-      "dependencies": {
-        "@isaacs/balanced-match": "^4.0.1"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@js-sdsl/ordered-map": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz",
-      "integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==",
-      "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/js-sdsl"
-      }
-    },
-    "node_modules/@lukeed/ms": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/@lukeed/ms/-/ms-2.0.2.tgz",
-      "integrity": "sha512-9I2Zn6+NJLfaGoz9jN3lpwDgAYvfGeNYdbAIjJOqzs4Tpc+VU3Jqq4IofSUBKajiDS8k9fZIg18/z13mpk1bsA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -1221,12 +814,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/@pinojs/redact": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz",
-      "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
-      "license": "MIT"
-    },
     "node_modules/@pkgr/core": {
       "version": "0.2.9",
       "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz",
@@ -1420,6 +1007,16 @@
         "form-data": "^4.0.4"
       }
     },
+    "node_modules/@types/protobufjs": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@types/protobufjs/-/protobufjs-6.0.0.tgz",
+      "integrity": "sha512-A27RDExpAf3rdDjIrHKiJK6x8kqqJ4CmoChwtipfhVAn1p7+wviQFFP7dppn8FslSbHtQeVPvi8wNKkDjSYjHw==",
+      "deprecated": "This is a stub types definition for protobufjs (https://github.com/dcodeIO/ProtoBuf.js). protobufjs provides its own type definitions, so you don't need @types/protobufjs installed!",
+      "license": "MIT",
+      "dependencies": {
+        "protobufjs": "*"
+      }
+    },
     "node_modules/@types/qs": {
       "version": "6.14.0",
       "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz",
@@ -1825,6 +1422,15 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
+    "node_modules/@zod/core": {
+      "version": "0.11.6",
+      "resolved": "https://registry.npmjs.org/@zod/core/-/core-0.11.6.tgz",
+      "integrity": "sha512-03Bv82fFSfjDAvMfdHHdGSS6SOJs0iCcJlWJv1kJHRtoTT02hZpyip/2Lk6oo4l4FtjuwTrsEQTwg/LD8I7dJA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
     "node_modules/abort-controller": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
@@ -1837,12 +1443,6 @@
         "node": ">=6.5"
       }
     },
-    "node_modules/abstract-logging": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/abstract-logging/-/abstract-logging-2.0.1.tgz",
-      "integrity": "sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==",
-      "license": "MIT"
-    },
     "node_modules/accepts": {
       "version": "1.3.8",
       "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
@@ -1935,30 +1535,6 @@
         "sql.js": "^0.5.0"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "6.2.3",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
-      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
     "node_modules/anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
@@ -2004,15 +1580,6 @@
       "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
       "license": "MIT"
     },
-    "node_modules/atomic-sleep": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz",
-      "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
@@ -2028,16 +1595,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/avvio": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/avvio/-/avvio-9.1.0.tgz",
-      "integrity": "sha512-fYASnYi600CsH/j9EQov7lECAniYiBFiiAtBNuZYLA2leLe9qOvZzqYHFjtIj6gD2VMoMLP14834LFWvr4IfDw==",
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/error": "^4.0.0",
-        "fastq": "^1.17.1"
-      }
-    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -2261,7 +1818,6 @@
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
       "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.1.0",
@@ -2278,7 +1834,6 @@
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
       "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-convert": "^2.0.1"
@@ -2294,7 +1849,6 @@
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
       "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -2304,7 +1858,6 @@
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
       "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "has-flag": "^4.0.0"
@@ -2347,93 +1900,6 @@
         "fsevents": "~2.3.2"
       }
     },
-    "node_modules/cliui": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
-      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/cliui/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cliui/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/cliui/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
-    },
-    "node_modules/cliui/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cliui/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cliui/node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2523,6 +1989,7 @@
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
       "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
@@ -2689,15 +2156,6 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/dequal": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
-      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/destroy": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
@@ -2734,24 +2192,12 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "license": "MIT"
-    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
       "license": "MIT"
     },
-    "node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "license": "MIT"
-    },
     "node_modules/encodeurl": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
@@ -2857,15 +2303,6 @@
         "@esbuild/win32-x64": "0.25.12"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
@@ -3207,13 +2644,7 @@
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/fast-decode-uri-component": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/fast-decode-uri-component/-/fast-decode-uri-component-1.0.1.tgz",
-      "integrity": "sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==",
-      "license": "MIT"
+      }
     },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
@@ -3252,30 +2683,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fast-json-stringify": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/fast-json-stringify/-/fast-json-stringify-6.1.1.tgz",
-      "integrity": "sha512-DbgptncYEXZqDUOEl4krff4mUiVrTZZVI7BBrQR/T3BqMj/eM1flTC1Uk2uUoLcWCxjT95xKulV/Lc6hhOZsBQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/merge-json-schemas": "^0.2.0",
-        "ajv": "^8.12.0",
-        "ajv-formats": "^3.0.1",
-        "fast-uri": "^3.0.0",
-        "json-schema-ref-resolver": "^3.0.0",
-        "rfdc": "^1.2.0"
-      }
-    },
     "node_modules/fast-levenshtein": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
@@ -3283,15 +2690,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fast-querystring": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/fast-querystring/-/fast-querystring-1.1.2.tgz",
-      "integrity": "sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==",
-      "license": "MIT",
-      "dependencies": {
-        "fast-decode-uri-component": "^1.0.1"
-      }
-    },
     "node_modules/fast-uri": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
@@ -3308,59 +2706,11 @@
       ],
       "license": "BSD-3-Clause"
     },
-    "node_modules/fastify": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/fastify/-/fastify-5.6.2.tgz",
-      "integrity": "sha512-dPugdGnsvYkBlENLhCgX8yhyGCsCPrpA8lFWbTNU428l+YOnLgYHR69hzV8HWPC79n536EqzqQtvhtdaCE0dKg==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/ajv-compiler": "^4.0.0",
-        "@fastify/error": "^4.0.0",
-        "@fastify/fast-json-stringify-compiler": "^5.0.0",
-        "@fastify/proxy-addr": "^5.0.0",
-        "abstract-logging": "^2.0.1",
-        "avvio": "^9.0.0",
-        "fast-json-stringify": "^6.0.0",
-        "find-my-way": "^9.0.0",
-        "light-my-request": "^6.0.0",
-        "pino": "^10.1.0",
-        "process-warning": "^5.0.0",
-        "rfdc": "^1.3.1",
-        "secure-json-parse": "^4.0.0",
-        "semver": "^7.6.0",
-        "toad-cache": "^3.7.0"
-      }
-    },
-    "node_modules/fastify-plugin": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/fastify-plugin/-/fastify-plugin-5.1.0.tgz",
-      "integrity": "sha512-FAIDA8eovSt5qcDgcBvDuX/v0Cjz0ohGhENZ/wpc3y+oZCY2afZ9Baqql3g/lC+OHRnciQol4ww7tuthOb9idw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
     "node_modules/fastq": {
       "version": "1.19.1",
       "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
       "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "reusify": "^1.0.4"
@@ -3428,20 +2778,6 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/find-my-way": {
-      "version": "9.3.0",
-      "resolved": "https://registry.npmjs.org/find-my-way/-/find-my-way-9.3.0.tgz",
-      "integrity": "sha512-eRoFWQw+Yv2tuYlK2pjFS2jGXSxSppAs3hSQjfxVKxM5amECzIgYYc1FEI8ZmhSh/Ig+FrKEz43NLRKJjYCZVg==",
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-querystring": "^1.0.0",
-        "safe-regex2": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
     "node_modules/find-up": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
@@ -3495,22 +2831,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -3594,15 +2914,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/get-caller-file": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
-      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
-      "license": "ISC",
-      "engines": {
-        "node": "6.* || 8.* || >= 10.*"
-      }
-    },
     "node_modules/get-intrinsic": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
@@ -3666,29 +2977,6 @@
         "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
       }
     },
-    "node_modules/glob": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz",
-      "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "foreground-child": "^3.3.1",
-        "jackspeak": "^4.1.1",
-        "minimatch": "^10.1.1",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^2.0.0"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -3702,21 +2990,6 @@
         "node": ">= 6"
       }
     },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "10.1.1",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz",
-      "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/brace-expansion": "^5.0.0"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/globals": {
       "version": "14.0.0",
       "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
@@ -4003,15 +3276,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -4075,23 +3339,9 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
       "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
       "license": "ISC"
     },
-    "node_modules/jackspeak": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz",
-      "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/js-yaml": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
@@ -4112,65 +3362,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/json-schema-ref-resolver": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-ref-resolver/-/json-schema-ref-resolver-3.0.0.tgz",
-      "integrity": "sha512-hOrZIVL5jyYFjzk7+y7n5JDzGlU8rfWDuYyHwGa2WA8/pcmMHezp2xsVwxrebD/Q9t8Nc5DboieySDpCp4WG4A==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "dequal": "^2.0.3"
-      }
-    },
-    "node_modules/json-schema-resolver": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-resolver/-/json-schema-resolver-3.0.0.tgz",
-      "integrity": "sha512-HqMnbz0tz2DaEJ3ntsqtx3ezzZyDE7G56A/pPY/NGmrPu76UzsWquOpHFRAf5beTNXoH2LU5cQePVvRli1nchA==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.1.1",
-        "fast-uri": "^3.0.5",
-        "rfdc": "^1.1.4"
-      },
-      "engines": {
-        "node": ">=20"
-      },
-      "funding": {
-        "url": "https://github.com/Eomm/json-schema-resolver?sponsor=1"
-      }
-    },
-    "node_modules/json-schema-resolver/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/json-schema-resolver/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
     "node_modules/json-schema-traverse": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
@@ -4206,13 +3397,6 @@
         "json-buffer": "3.0.1"
       }
     },
-    "node_modules/koffi": {
-      "version": "2.13.0",
-      "resolved": "https://registry.npmjs.org/koffi/-/koffi-2.13.0.tgz",
-      "integrity": "sha512-VqQzBC7XBVJHXA4DkmY68HbH8VTYVaBKq3MFlziI+pdJXIpd/lO4LeXKo2YpIhuTkLgXYra+dDjJOo2+yT1Tsg==",
-      "hasInstallScript": true,
-      "license": "MIT"
-    },
     "node_modules/levn": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
@@ -4236,52 +3420,6 @@
         "immediate": "~3.0.5"
       }
     },
-    "node_modules/light-my-request": {
-      "version": "6.6.0",
-      "resolved": "https://registry.npmjs.org/light-my-request/-/light-my-request-6.6.0.tgz",
-      "integrity": "sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "cookie": "^1.0.1",
-        "process-warning": "^4.0.0",
-        "set-cookie-parser": "^2.6.0"
-      }
-    },
-    "node_modules/light-my-request/node_modules/cookie": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
-      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/light-my-request/node_modules/process-warning": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-4.0.1.tgz",
-      "integrity": "sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -4298,12 +3436,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lodash.camelcase": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
-      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
-      "license": "MIT"
-    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -4323,15 +3455,6 @@
       "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
       "license": "Apache-2.0"
     },
-    "node_modules/lru-cache": {
-      "version": "11.2.2",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz",
-      "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==",
-      "license": "ISC",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
     "node_modules/make-dir": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz",
@@ -4459,24 +3582,6 @@
         "node": "*"
       }
     },
-    "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/mnemonist": {
-      "version": "0.40.0",
-      "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.40.0.tgz",
-      "integrity": "sha512-kdd8AFNig2AD5Rkih7EPCXhu/iMvwevQFX/uEiGhZyPZi7fHqOoF4V4kHLpCfysxXMgQ4B52kdPMCwARshKvEg==",
-      "license": "MIT",
-      "dependencies": {
-        "obliterator": "^2.0.4"
-      }
-    },
     "node_modules/ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
@@ -4633,21 +3738,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/obliterator": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/obliterator/-/obliterator-2.0.5.tgz",
-      "integrity": "sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw==",
-      "license": "MIT"
-    },
-    "node_modules/on-exit-leak-free": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
-      "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
     "node_modules/on-finished": {
       "version": "2.4.1",
       "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
@@ -4669,12 +3759,6 @@
         "wrappy": "1"
       }
     },
-    "node_modules/openapi-types": {
-      "version": "12.1.3",
-      "resolved": "https://registry.npmjs.org/openapi-types/-/openapi-types-12.1.3.tgz",
-      "integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
-      "license": "MIT"
-    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -4725,12 +3809,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
-      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "license": "BlueOak-1.0.0"
-    },
     "node_modules/pako": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
@@ -4773,27 +3851,12 @@
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
       "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/path-scurry": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz",
-      "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^11.0.0",
-        "minipass": "^7.1.2"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/path-to-regexp": {
       "version": "0.1.12",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
@@ -4849,43 +3912,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/pino": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/pino/-/pino-10.1.0.tgz",
-      "integrity": "sha512-0zZC2ygfdqvqK8zJIr1e+wT1T/L+LF6qvqvbzEQ6tiMAoTqEVK9a1K3YRu8HEUvGEvNqZyPJTtb2sNIoTkB83w==",
-      "license": "MIT",
-      "dependencies": {
-        "@pinojs/redact": "^0.4.0",
-        "atomic-sleep": "^1.0.0",
-        "on-exit-leak-free": "^2.1.0",
-        "pino-abstract-transport": "^2.0.0",
-        "pino-std-serializers": "^7.0.0",
-        "process-warning": "^5.0.0",
-        "quick-format-unescaped": "^4.0.3",
-        "real-require": "^0.2.0",
-        "safe-stable-stringify": "^2.3.1",
-        "sonic-boom": "^4.0.1",
-        "thread-stream": "^3.0.0"
-      },
-      "bin": {
-        "pino": "bin.js"
-      }
-    },
-    "node_modules/pino-abstract-transport": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz",
-      "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==",
-      "license": "MIT",
-      "dependencies": {
-        "split2": "^4.0.0"
-      }
-    },
-    "node_modules/pino-std-serializers": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz",
-      "integrity": "sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==",
-      "license": "MIT"
-    },
     "node_modules/possible-typed-array-names": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
@@ -4936,24 +3962,8 @@
     },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
-      "license": "MIT"
-    },
-    "node_modules/process-warning": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz",
-      "integrity": "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "license": "MIT"
     },
     "node_modules/protobufjs": {
@@ -5046,12 +4056,6 @@
       ],
       "license": "MIT"
     },
-    "node_modules/quick-format-unescaped": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz",
-      "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==",
-      "license": "MIT"
-    },
     "node_modules/range-parser": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
@@ -5110,24 +4114,6 @@
         "node": ">=8.10.0"
       }
     },
-    "node_modules/real-require": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz",
-      "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12.13.0"
-      }
-    },
-    "node_modules/require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/require-from-string": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
@@ -5157,31 +4143,17 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
-    "node_modules/ret": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/ret/-/ret-0.5.0.tgz",
-      "integrity": "sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/reusify": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
       "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "iojs": ">=1.0.0",
         "node": ">=0.10.0"
       }
     },
-    "node_modules/rfdc": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
-      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
-      "license": "MIT"
-    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -5226,56 +4198,12 @@
       ],
       "license": "MIT"
     },
-    "node_modules/safe-regex2": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/safe-regex2/-/safe-regex2-5.0.0.tgz",
-      "integrity": "sha512-YwJwe5a51WlK7KbOJREPdjNrpViQBI3p4T50lfwPuDhZnE3XGVTlGvi+aolc5+RvxDD6bnUmjVsU9n1eboLUYw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "ret": "~0.5.0"
-      }
-    },
-    "node_modules/safe-stable-stringify": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
-      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
-    "node_modules/secure-json-parse": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-4.1.0.tgz",
-      "integrity": "sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
     "node_modules/seek-bzip": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.6.tgz",
@@ -5293,6 +4221,7 @@
       "version": "7.7.2",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
       "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "dev": true,
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -5355,12 +4284,6 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/set-cookie-parser": {
-      "version": "2.7.2",
-      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
-      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
-      "license": "MIT"
-    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -5407,6 +4330,7 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
       "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "shebang-regex": "^3.0.0"
@@ -5419,6 +4343,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -5496,18 +4421,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/simple-update-notifier": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
@@ -5521,24 +4434,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/sonic-boom": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.0.tgz",
-      "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==",
-      "license": "MIT",
-      "dependencies": {
-        "atomic-sleep": "^1.0.0"
-      }
-    },
-    "node_modules/split2": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-      "license": "ISC",
-      "engines": {
-        "node": ">= 10.x"
-      }
-    },
     "node_modules/sql.js": {
       "version": "0.5.0",
       "resolved": "https://registry.npmjs.org/sql.js/-/sql.js-0.5.0.tgz",
@@ -5569,102 +4464,6 @@
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "license": "MIT"
     },
-    "node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
-    },
-    "node_modules/string-width-cjs/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
-      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/strip-dirs": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz",
@@ -5734,15 +4533,6 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/thread-stream": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
-      "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==",
-      "license": "MIT",
-      "dependencies": {
-        "real-require": "^0.2.0"
-      }
-    },
     "node_modules/through": {
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
@@ -5782,15 +4572,6 @@
         "node": ">=8.0"
       }
     },
-    "node_modules/toad-cache": {
-      "version": "3.7.0",
-      "resolved": "https://registry.npmjs.org/toad-cache/-/toad-cache-3.7.0.tgz",
-      "integrity": "sha512-/m8M+2BJUpoJdgAHoG+baCwBT+tf2VraSfkBgl0Y00qIWt41DJ8R5B8nsEw0I58YwF5IZH6z24/2TobDKnqSWw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/toidentifier": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
@@ -6035,6 +4816,7 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
       "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "isexe": "^2.0.0"
@@ -6077,97 +4859,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
@@ -6204,95 +4895,6 @@
         "node": ">=0.4"
       }
     },
-    "node_modules/y18n": {
-      "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yaml": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz",
-      "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==",
-      "license": "ISC",
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14.6"
-      }
-    },
-    "node_modules/yargs": {
-      "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
-      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^8.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yargs-parser": {
-      "version": "21.1.1",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
-      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yargs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/yargs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
-    },
-    "node_modules/yargs/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/yargs/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/yauzl": {
       "version": "2.10.0",
       "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
@@ -6315,6 +4917,25 @@
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
+    },
+    "node_modules/zod": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.2.1.tgz",
+      "integrity": "sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.1",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.1.tgz",
+      "integrity": "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25 || ^4"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index 5a52a59..19fbda3 100644
--- a/package.json
+++ b/package.json
@@ -43,7 +43,7 @@
     "typescript-eslint": "^8.0.0"
   },
   "dependencies": {
-    "@inworld/runtime": "^0.8.0",
+    "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
     "anki-apkg-export": "^4.0.3",
     "dotenv": "^17.2.1",
     "express": "^4.19.2",
diff --git a/realtime-service/.env-sample b/realtime-service/.env-sample
new file mode 100644
index 0000000..ffdcd2e
--- /dev/null
+++ b/realtime-service/.env-sample
@@ -0,0 +1,39 @@
+# DO NOT EDIT THIS FILE DIRECTLY
+# Copy this file to .env and enter your own values
+#
+# INWORLD_API_KEY is required
+INWORLD_API_KEY=
+# ASSEMBLYAI_API_KEY is required for audio transcription
+ASSEMBLYAI_API_KEY=
+# VAD_MODEL_PATH is optional, defaults to packaged https://github.com/snakers4/silero-vad
+VAD_MODEL_PATH=
+# LLM_MODEL_NAME is optional, defaults to `gpt-4o-mini`
+LLM_MODEL_NAME=
+# LLM_PROVIDER is optional, defaults to `openai`
+LLM_PROVIDER=
+# VOICE_ID is optional, defaults to `Dennis`
+VOICE_ID=
+# TTS_MODEL_ID is optional, defaults to `inworld-tts-1`
+TTS_MODEL_ID=
+# If enabled, it will be saved in system tmp folder.
+# Path will be printed in CLI on application start.
+# Default value is `false`, set `true` to enable this feature
+GRAPH_VISUALIZATION_ENABLED=
+# If enabled, the user can stop the agent's audio playback with
+# text or speech input. For speech input use case, users could accidentally interrupt
+# in the case of false postivie speech detection. You can tune the following parameters
+# to achieve the right level of speech detection sensitivy for your application:
+# MIN_SPEECH_DURATION_MS, PAUSE_DURATION_THRESHOLD_MS, SPEECH_THRESHOLD
+# AUTH_TOKEN is optional, but recommended for basic security.
+# If set, clients must provide this token in the Authorization header.
+AUTH_TOKEN=
+
+# Logging configuration
+# REALTIME_LOG_LEVEL: 'debug', 'info', 'warn', 'error' (default: 'info')
+# REALTIME_LOG_PRETTY: '1' to enable pretty logs locally (default: '0' = JSON)
+# Examples:
+#   npm start                              # JSON logs (default, cloud-ready)
+#   REALTIME_LOG_PRETTY=1 npm start        # Pretty logs (local dev)
+#   REALTIME_LOG_LEVEL=debug npm start     # JSON with debug level
+REALTIME_LOG_LEVEL=info
+REALTIME_LOG_PRETTY=1
\ No newline at end of file
diff --git a/realtime-service/Makefile b/realtime-service/Makefile
new file mode 100644
index 0000000..711dd59
--- /dev/null
+++ b/realtime-service/Makefile
@@ -0,0 +1,53 @@
+.PHONY: build docker-build docker-run local-install local-start local-build help
+
+# Docker image name
+IMAGE_NAME ?= oai-realtime-api-voice-agent
+IMAGE_TAG ?= latest
+
+GH_TOKEN ?=
+
+# Default target
+help:
+	@echo "Available commands:"
+	@echo "  make docker-build    - Build Docker image"
+	@echo "  make docker-run      - Run Docker container"
+	@echo "  make local-install   - Install dependencies locally"
+	@echo "  make local-start     - Start server locally (development mode)"
+	@echo "  make local-build     - Build TypeScript project locally"
+	@echo "  make help           - Show this help message"
+	@echo ""
+	@echo "Note: For docker-build, you can set GITHUB_TOKEN environment variable"
+	@echo "      to download @inworld/runtime binaries from GitHub:"
+	@echo "      GH_TOKEN=your_token make docker-build"
+
+# Build Docker image
+docker-build:
+	@echo "Building Docker image: $(IMAGE_NAME):$(IMAGE_TAG)"
+	@if [ -n "$(GH_TOKEN)" ]; then \
+		echo "Using GH_TOKEN for downloading binaries..."; \
+		docker build --platform linux/amd64 --build-arg GH_TOKEN=$(GH_TOKEN) --build-arg SERVICE_PATH=serving/realtime-service --build-arg SERVICE_PORT=4000 -t $(IMAGE_NAME):$(IMAGE_TAG) -f ../../.github/builds/Dockerfile.node-service.common ../..; \
+	else \
+		echo "Warning: GH_TOKEN not set. Build may fail if @inworld/runtime binaries require authentication."; \
+		docker build --platform linux/amd64 --build-arg SERVICE_PATH=serving/realtime-service --build-arg SERVICE_PORT=4000 -t $(IMAGE_NAME):$(IMAGE_TAG) -f ../../.github/builds/Dockerfile.node-service.common ../..; \
+	fi
+
+# Run Docker container
+docker-run:
+	@echo "Running Docker container: $(IMAGE_NAME):$(IMAGE_TAG)"
+	docker run --platform linux/amd64 -p 4000:4000 -p 9000:9000 --env-file .env -e LLM_PROVIDER=groq -e LLM_MODEL_NAME=llama-3.3-70b-versatile $(IMAGE_NAME):$(IMAGE_TAG)
+
+# Install dependencies locally
+local-install:
+	@echo "Installing dependencies..."
+	cd server && npm install
+
+# Build TypeScript project locally
+local-build:
+	@echo "Building TypeScript project..."
+	cd server && npm run build
+
+# Start server locally (development mode with nodemon)
+local-start: local-install
+	@echo "Starting server locally..."
+	cd server && npm start
+
diff --git a/realtime-service/README.md b/realtime-service/README.md
new file mode 100644
index 0000000..7ba1c04
--- /dev/null
+++ b/realtime-service/README.md
@@ -0,0 +1,91 @@
+# Inworld Realtime Service
+
+This is an Inworld service that implements a web-sockets OpenAI Realtime API compatible API.
+
+## Building and Running with Docker
+
+### Build Docker Image
+
+```bash
+make docker-build
+```
+
+Optionally, you can provide a GitHub token to download `@inworld/runtime` binaries:
+
+```bash
+GH_TOKEN=your_token make docker-build
+```
+
+### Run Docker Container
+
+```bash
+make docker-run
+```
+
+This will run the container on port 4000. Make sure you have a `.env` file in the root directory with the required environment variables.
+
+## Building and Running without Docker
+
+### Install Dependencies
+
+```bash
+cd src
+npm install
+```
+
+### Build Project
+
+```bash
+cd src
+npm run build
+```
+
+### Run the Server
+
+For development (with nodemon):
+
+```bash
+cd src
+npm start
+```
+
+The server will start on port 4000 by default (or the port specified in your environment variables).
+
+## Configuration
+
+### Logging
+
+The service outputs JSON logs by default (Google Cloud Logging compatible).
+
+**Environment Variables:**
+- `REALTIME_LOG_LEVEL` - Log level: `debug`, `info`, `warn`, `error` (default: `info`)
+- `REALTIME_LOG_PRETTY` - Set to `1` for human-readable logs during development (default: `0` = JSON)
+
+**Examples:**
+```bash
+npm start                                      # JSON logs (production-ready)
+REALTIME_LOG_PRETTY=1 npm start                # Pretty logs (local dev)
+REALTIME_LOG_LEVEL=debug npm start             # JSON with debug level
+REALTIME_LOG_PRETTY=1 REALTIME_LOG_LEVEL=debug npm start  # Pretty with debug level
+```
+
+See [LOGGING.md](LOGGING.md) for detailed logging best practices.
+
+## Test websocket connection
+### Locally running w-proxy and realtime service
+```
+ws://localhost:8081/api/v1/realtime/session?key=<session-id>&protocol=realtime
+```
+with Authorization header
+
+### Dev: running w-proxy and realtime service
+```
+wss://api.dev.inworld.ai:443/api/v1/realtime/session?key=<session-id>&protocol=realtime
+```
+with Authorization header
+
+### Dev: tailscale and directly to realtime service
+```
+ws://realtime-service-dev.tail4c73a.ts.net:4000/session?key=<session-id>&protocol=realtime
+```
+no need to provide Authorization header (debug only)
diff --git a/realtime-service/__tests__/README.md b/realtime-service/__tests__/README.md
new file mode 100644
index 0000000..1ba3380
--- /dev/null
+++ b/realtime-service/__tests__/README.md
@@ -0,0 +1,469 @@
+# Realtime Service Tests
+
+Comprehensive API-level integration tests for the OpenAI Realtime API WebSocket service.
+
+## Quick Start
+
+### 1. Install Dependencies
+```bash
+npm install
+```
+
+### 2. Start Server (Terminal 1)
+```bash
+cd src && npm start
+```
+Wait for: `Application Server listening on port 4000`
+
+### 3. Run Tests (Terminal 2)
+```bash
+npm test
+```
+
+That's it! ✅
+
+> **TL;DR:** See [`SIMPLE_START.md`](./SIMPLE_START.md) for the absolute quickest guide.
+
+---
+
+## Table of Contents
+
+- [What We Test](#what-we-test)
+- [Running Tests](#running-tests)
+- [Writing Tests](#writing-tests)
+- [Test Utilities](#test-utilities)
+- [Troubleshooting](#troubleshooting)
+- [Why API Tests Only](#why-api-tests-only)
+- [CI/CD Integration](#cicd-integration)
+
+---
+
+## What We Test
+
+We use **API-level integration tests** that validate complete WebSocket behavior:
+
+✅ **Session Management** (3 tests) - Creation, configuration, turn detection  
+✅ **Conversation Management** (5 tests) - CRUD operations on items  
+✅ **Response Generation** (4 tests) - Complete response lifecycle  
+✅ **Function Calling** (1 test) - Tool execution  
+✅ **Audio Input** (1 test) - Buffer operations  
+✅ **Error Handling** (2 tests) - Invalid requests  
+✅ **Multi-Session** (1 test) - Concurrent sessions  
+✅ **Workspace Isolation** (1 test) - Multi-tenancy  
+
+**Total: 18 passing tests, 1 skipped** (~6 seconds runtime)
+
+---
+
+## Running Tests
+
+### Basic Commands
+
+```bash
+# Run all tests (requires server running)
+npm test
+
+# Run in watch mode
+npm run test:watch
+
+# Run with coverage report
+npm run test:coverage
+
+# Run specific test
+npm test -- -t "should create a session"
+```
+
+### Environment Variables
+
+Optionally create `.env.test` in the project root:
+
+```bash
+INWORLD_API_KEY=your-api-key
+WORKSPACE_ID=your-workspace-id
+```
+
+**Note:** `WS_APP_PORT` is automatically managed by tests - they find an available port dynamically.
+
+---
+
+## Writing Tests
+
+### Test Structure
+
+```typescript
+import { v4 as uuidv4 } from 'uuid';
+import { createWebSocketTestClient, createTextMessage } from './websocket-test-helper';
+
+it('should test some API behavior', async () => {
+  // 1. Create client with unique session ID
+  const sessionKey = `test-session-${uuidv4()}`;
+  const client = await createWebSocketTestClient(sessionKey, 4000);
+  
+  try {
+    // 2. Wait for session initialization
+    await client.waitForEvent('session.created');
+    
+    // 3. Send client event
+    client.sendEvent({
+      type: 'conversation.item.create',
+      item: createTextMessage('Hello, world!'),
+    });
+    
+    // 4. Verify server response
+    const addedEvent = await client.waitForEvent('conversation.item.added');
+    expect(addedEvent.item.content[0].text).toBe('Hello, world!');
+    
+  } finally {
+    // 5. Always clean up
+    await client.close();
+  }
+});
+```
+
+### Best Practices
+
+✅ **Use unique session IDs** - `uuidv4()` for each test  
+✅ **Always close connections** - Use try/finally blocks  
+✅ **Set appropriate timeouts** - Default is 5000ms, adjust if needed  
+✅ **Test both success and errors** - Don't just test happy paths  
+✅ **Keep tests independent** - No shared state between tests  
+
+---
+
+## Test Utilities
+
+### Creating a Test Client
+
+```typescript
+const client = await createWebSocketTestClient(
+  'session-123',  // session key
+  4000,           // port (optional, defaults to 3001)
+  'workspace-id'  // workspace ID (optional)
+);
+```
+
+### Waiting for Events
+
+```typescript
+// Wait for single event
+const event = await client.waitForEvent('session.created', 5000);
+
+// Wait for multiple events in sequence
+const [event1, event2] = await client.waitForEvents([
+  'conversation.item.added',
+  'conversation.item.done'
+], 10000);
+
+// Wait for complete response cycle
+const response = await waitForCompleteResponse(client);
+const text = extractTextFromResponse(response.allEvents);
+```
+
+### Sending Events
+
+```typescript
+// Send any client event
+client.sendEvent({
+  type: 'conversation.item.create',
+  item: createTextMessage('Hello'),
+});
+
+// Create different message types
+const userMsg = createTextMessage('Hello', 'user', 'msg-123');
+const functionOutput = createFunctionCallOutput('call-123', '{"result": true}');
+```
+
+### Assertions
+
+```typescript
+// Assert event properties
+assertEvent(event, 'session.created', (evt) => {
+  expect(evt.session.id).toBeDefined();
+  expect(evt.session.model).toBe('expected-model');
+});
+```
+
+### All Helper Functions
+
+- `createWebSocketTestClient()` - Create test client
+- `waitForEvent()` - Wait for specific event
+- `waitForEvents()` - Wait for multiple events
+- `waitForCompleteResponse()` - Wait for full response
+- `assertEvent()` - Assert event properties
+- `createTextMessage()` - Create text message item
+- `createFunctionCallOutput()` - Create function output
+- `extractTextFromResponse()` - Extract text from events
+- `extractAudioTranscriptFromResponse()` - Extract audio transcript
+
+See [`api/README.md`](./api/README.md) for detailed API documentation.
+
+---
+
+## Troubleshooting
+
+### Connection Refused
+
+**Problem:** Tests fail with `ECONNREFUSED`  
+**Solution:** Start the server first:
+```bash
+cd src && npm start
+```
+Wait for "Application Server listening on port 4000", then run tests.
+
+### Tests Timeout
+
+**Problem:** Tests timeout waiting for events  
+**Solutions:**
+- Check server logs for errors
+- Verify environment variables are set
+- Increase timeout: `await client.waitForEvent('event', 30000)`
+- Make sure server is running on correct port (4000)
+
+### Port Already in Use
+
+**Problem:** Can't start server - port 4000 in use  
+**Solution:**
+```bash
+# Kill process on port 4000
+lsof -ti:4000 | xargs kill
+
+# Or use different port
+WS_APP_PORT=4001 npm start  # Terminal 1
+WS_APP_PORT=4001 npm test   # Terminal 2
+```
+
+### Module Not Found
+
+**Problem:** `Cannot find module 'uuid'`  
+**Solution:** Run `npm install`
+
+### Debugging Tests
+
+```typescript
+// View all received events
+it('debug test', async () => {
+  const client = await createWebSocketTestClient('test');
+  await client.waitForEvent('session.created');
+  
+  console.log('Events:', JSON.stringify(client.events, null, 2));
+});
+
+// Increase timeout for debugging
+jest.setTimeout(300000); // 5 minutes
+```
+
+---
+
+## Why API Tests Only?
+
+We chose **API integration tests** over traditional unit tests.
+
+### What We DON'T Do ❌
+
+```typescript
+// Unit testing internal nodes (we avoid this)
+it('node should process input', () => {
+  const node = new TextInputNode(config);
+  const result = node.process(context, input);
+  expect(result.messages).toContainEqual(...);
+});
+```
+**Problem:** Tests implementation details, breaks on refactoring
+
+### What We DO ✅
+
+```typescript
+// Testing API behavior (our approach)
+it('should create conversation item', async () => {
+  const client = await createWebSocketTestClient('session-123');
+  await client.waitForEvent('session.created');
+  
+  client.sendEvent({
+    type: 'conversation.item.create',
+    item: createTextMessage('Hello'),
+  });
+  
+  const event = await client.waitForEvent('conversation.item.added');
+  expect(event.item.content[0].text).toBe('Hello');
+});
+```
+**Benefit:** Tests actual behavior, survives refactoring
+
+### Benefits
+
+1. **Tests Real Behavior** - Validates what users actually experience
+2. **OpenAI Compliance** - Ensures API contract adherence
+3. **Refactor-Safe** - Tests survive internal code changes
+4. **Living Documentation** - Tests show how to use the API
+5. **Higher Confidence** - Tests complete integration paths
+6. **Fewer Tests** - 18 comprehensive tests vs 100+ unit tests
+
+### Trade-offs
+
+We accept these trade-offs for better overall testing:
+
+- ⚠️ Requires running server (~1 command in separate terminal)
+- ⚠️ Slower execution (~6 seconds vs milliseconds for unit tests)
+- ⚠️ May need environment configuration for API keys
+- ⚠️ Debugging spans multiple components
+
+**Result:** Better testing with less maintenance burden. Simple setup, comprehensive coverage!
+
+---
+
+## CI/CD Integration
+
+### GitHub Actions Example
+
+```yaml
+name: API Tests
+
+on: [push, pull_request]
+
+jobs:
+  api-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '18'
+      
+      - name: Install dependencies
+        run: npm install
+        
+      - name: Start server
+        run: cd src && npm start &
+        
+      - name: Wait for server
+        run: sleep 5
+        
+      - name: Run tests
+        run: npm test
+        
+      - name: Upload coverage
+        uses: codecov/codecov-action@v2
+        if: always()
+```
+
+---
+
+## Project Structure
+
+```
+__tests__/
+├── api/
+│   ├── realtime-api.spec.ts      # 18 test cases
+│   ├── websocket-test-helper.ts  # Test utilities
+│   ├── websocket-server-helper.ts
+│   └── README.md                 # Detailed API docs
+│
+├── utils/                        # Legacy (kept for reference)
+│   ├── mock-helpers.ts
+│   └── graph-test-helpers.ts
+│
+├── config.ts                     # Test constants
+├── setup.ts                      # Jest setup
+├── test-setup.ts                 # Test environment
+└── README.md                     # This file
+```
+
+---
+
+## Test Statistics
+
+- **Test Files:** 1 (`realtime-api.spec.ts`)
+- **Test Cases:** 18 passing, 1 skipped
+- **Test Duration:** ~6 seconds
+- **Test Categories:** 8
+- **Lines of Code:** ~1,100 test code
+
+### Latest Results
+
+```
+PASS __tests__/api/realtime-api.spec.ts (6.704 s)
+  ✓ Session Management (3/3)
+  ✓ Conversation Management (5/5)
+  ✓ Response Generation (4/4)
+  ✓ Function Calling (1/1)
+  ✓ Audio Input Management (1/2, 1 skipped)
+  ✓ Error Handling (2/2)
+  ✓ Multi-Session Support (1/1)
+  ✓ Workspace Isolation (1/1)
+
+Tests: 18 passed, 1 skipped, 19 total
+Time: 6.826 s
+```
+
+---
+
+## Configuration
+
+### Jest (`jest.config.js`)
+
+- Timeout: 30 seconds
+- Environment: Node.js
+- Uses: ts-jest with `tsconfig.test.json`
+
+### TypeScript (`tsconfig.test.json`)
+
+- Extends: `src/tsconfig.json`
+- Includes: `__tests__/**/*.ts`
+- CommonJS modules for Jest compatibility
+
+### Environment (`.env.test`)
+
+```bash
+WS_APP_PORT=4000
+INWORLD_API_KEY=your-key
+WORKSPACE_ID=your-workspace
+```
+
+---
+
+## Contributing
+
+When adding new features:
+
+1. **Add API tests** for the new behavior
+2. **Test success and error cases**
+3. **Use existing tests as templates**
+4. **Update this README** if patterns change
+5. **Ensure all tests pass** before committing
+
+### Example: Adding a New Test
+
+```typescript
+describe('New Feature', () => {
+  let client: WebSocketTestClient;
+  const sessionKey = `test-session-${uuidv4()}`;
+
+  beforeEach(async () => {
+    client = await createWebSocketTestClient(sessionKey);
+    await client.waitForEvent('session.created');
+  });
+
+  afterEach(async () => {
+    if (client) await client.close();
+  });
+
+  it('should handle new feature', async () => {
+    // Test implementation
+  });
+});
+```
+
+---
+
+## Support
+
+- **Detailed API docs:** [`api/README.md`](./api/README.md)
+- **Jest documentation:** https://jestjs.io/
+- **WebSocket API spec:** Check `src/REALTIME_API.md`
+
+---
+
+**Last Updated:** November 2024  
+**Status:** ✅ All tests passing  
+**Test Coverage:** Run `npm run test:coverage` to check
diff --git a/realtime-service/__tests__/api/README.md b/realtime-service/__tests__/api/README.md
new file mode 100644
index 0000000..c9a7f86
--- /dev/null
+++ b/realtime-service/__tests__/api/README.md
@@ -0,0 +1,312 @@
+# API Test Utilities Reference
+
+Helper functions and utilities for writing API integration tests.
+
+> **Main Documentation:** See [`../__tests__/README.md`](../README.md) for complete testing guide.
+
+---
+
+## WebSocket Test Client
+
+### Creating a Client
+
+```typescript
+import { createWebSocketTestClient } from './websocket-test-helper';
+
+const client = await createWebSocketTestClient(
+  sessionKey,      // string: unique session identifier
+  port?,           // number: server port (default: 3001)
+  workspaceId?     // string: optional workspace ID
+);
+```
+
+### Client Interface
+
+```typescript
+interface WebSocketTestClient {
+  ws: WebSocket;                    // Raw WebSocket instance
+  events: RT.ServerEvent[];         // All received events
+  
+  // Wait for specific event
+  waitForEvent(eventType: string, timeout?: number): Promise<RT.ServerEvent>;
+  
+  // Wait for multiple events in sequence
+  waitForEvents(eventTypes: string[], timeout?: number): Promise<RT.ServerEvent[]>;
+  
+  // Send client event
+  sendEvent(event: RT.ClientEvent): void;
+  
+  // Close connection
+  close(): Promise<void>;
+}
+```
+
+---
+
+## Event Utilities
+
+### Wait for Event
+
+```typescript
+// Wait for single event (default 5s timeout)
+const event = await client.waitForEvent('session.created');
+
+// With custom timeout
+const event = await client.waitForEvent('response.done', 30000);
+```
+
+### Wait for Multiple Events
+
+```typescript
+const [event1, event2] = await client.waitForEvents([
+  'conversation.item.added',
+  'conversation.item.done'
+], 10000);
+```
+
+### Wait for Complete Response
+
+```typescript
+import { waitForCompleteResponse } from './websocket-test-helper';
+
+const response = await waitForCompleteResponse(client, 30000);
+// Returns: { created, done, allEvents }
+```
+
+### Collect Events Until
+
+```typescript
+import { collectEventsUntil } from './websocket-test-helper';
+
+const events = await collectEventsUntil(client, 'response.done', 10000);
+```
+
+---
+
+## Message Creation
+
+### Create Text Message
+
+```typescript
+import { createTextMessage } from './websocket-test-helper';
+
+// Basic
+const msg = createTextMessage('Hello, world!');
+
+// With role
+const userMsg = createTextMessage('Hello', 'user');
+const sysMsg = createTextMessage('Instructions', 'system');
+
+// With ID
+const msg = createTextMessage('Hello', 'user', 'msg-123');
+```
+
+Returns:
+```typescript
+{
+  type: 'message',
+  role: 'user' | 'assistant' | 'system',
+  content: [{ type: 'input_text', text: string }],
+  id?: string
+}
+```
+
+### Create Function Call Output
+
+```typescript
+import { createFunctionCallOutput } from './websocket-test-helper';
+
+const output = createFunctionCallOutput(
+  'call-123',                    // call_id
+  '{"temperature": 72}',         // output (JSON string)
+  'output-456'                   // optional id
+);
+```
+
+Returns:
+```typescript
+{
+  type: 'function_call_output',
+  call_id: string,
+  output: string,
+  id?: string
+}
+```
+
+---
+
+## Assertions
+
+### Assert Event Properties
+
+```typescript
+import { assertEvent } from './websocket-test-helper';
+
+// Basic assertion
+assertEvent(event, 'session.created');
+
+// With additional checks
+assertEvent(event, 'session.created', (evt) => {
+  expect(evt.session.id).toBeDefined();
+  expect(evt.session.model).toBe('expected-model');
+  expect(evt.session.audio.output.voice).toBe('Dennis');
+});
+```
+
+---
+
+## Response Utilities
+
+### Extract Text from Response
+
+```typescript
+import { extractTextFromResponse } from './websocket-test-helper';
+
+const response = await waitForCompleteResponse(client);
+const text = extractTextFromResponse(response.allEvents);
+
+console.log('Response text:', text);
+```
+
+### Extract Audio Transcript
+
+```typescript
+import { extractAudioTranscriptFromResponse } from './websocket-test-helper';
+
+const response = await waitForCompleteResponse(client);
+const transcript = extractAudioTranscriptFromResponse(response.allEvents);
+
+console.log('Audio transcript:', transcript);
+```
+
+---
+
+## Complete Example
+
+```typescript
+import { v4 as uuidv4 } from 'uuid';
+import {
+  createWebSocketTestClient,
+  createTextMessage,
+  waitForCompleteResponse,
+  extractTextFromResponse,
+  assertEvent,
+} from './websocket-test-helper';
+
+it('should handle conversation flow', async () => {
+  // Create client
+  const sessionKey = `test-${uuidv4()}`;
+  const client = await createWebSocketTestClient(sessionKey, 4000);
+  
+  try {
+    // Wait for session
+    const sessionEvent = await client.waitForEvent('session.created');
+    assertEvent(sessionEvent, 'session.created', (evt) => {
+      expect(evt.session.id).toBeDefined();
+    });
+    
+    // Create conversation item
+    client.sendEvent({
+      type: 'conversation.item.create',
+      item: createTextMessage('Hello, how are you?', 'user'),
+    });
+    
+    // Verify item was added
+    const [added, done] = await client.waitForEvents([
+      'conversation.item.added',
+      'conversation.item.done'
+    ]);
+    
+    assertEvent(added, 'conversation.item.added');
+    assertEvent(done, 'conversation.item.done');
+    
+    // Generate response
+    client.sendEvent({ type: 'response.create' });
+    
+    // Wait for complete response
+    const response = await waitForCompleteResponse(client, 30000);
+    const text = extractTextFromResponse(response.allEvents);
+    
+    expect(text.length).toBeGreaterThan(0);
+    
+  } finally {
+    await client.close();
+  }
+});
+```
+
+---
+
+## Server Management (Optional)
+
+For automated server lifecycle management:
+
+```typescript
+import {
+  startTestServer,
+  stopTestServer,
+  waitForServerReady,
+  getServerPort,
+} from './websocket-server-helper';
+
+// Start server
+const port = await startTestServer(4000);
+await waitForServerReady(port);
+
+// Run tests...
+
+// Stop server
+await stopTestServer();
+```
+
+---
+
+## Type Definitions
+
+All types are imported from `../../src/types/realtime`:
+
+```typescript
+import * as RT from '../../src/types/realtime';
+
+// Client events
+RT.ClientEvent
+RT.SessionUpdateEvent
+RT.ConversationItemCreateEvent
+RT.ResponseCreateEvent
+// ... etc
+
+// Server events
+RT.ServerEvent
+RT.SessionCreatedEvent
+RT.ConversationItemAddedEvent
+RT.ResponseCreatedEvent
+// ... etc
+
+// Data types
+RT.MessageItem
+RT.FunctionCallItem
+RT.FunctionCallOutputItem
+RT.Session
+RT.Response
+```
+
+---
+
+## Helper Function Summary
+
+| Function | Purpose |
+|----------|---------|
+| `createWebSocketTestClient()` | Create and connect test client |
+| `waitForEvent()` | Wait for specific event |
+| `waitForEvents()` | Wait for multiple events |
+| `waitForCompleteResponse()` | Wait for full response cycle |
+| `collectEventsUntil()` | Collect all events until target |
+| `assertEvent()` | Assert event type and properties |
+| `createTextMessage()` | Create text message item |
+| `createFunctionCallOutput()` | Create function output item |
+| `extractTextFromResponse()` | Extract text from response events |
+| `extractAudioTranscriptFromResponse()` | Extract audio transcript |
+
+---
+
+For complete testing documentation, examples, and troubleshooting, see the [main README](../README.md).
diff --git a/realtime-service/__tests__/api/realtime-api.spec.ts b/realtime-service/__tests__/api/realtime-api.spec.ts
new file mode 100644
index 0000000..85b8690
--- /dev/null
+++ b/realtime-service/__tests__/api/realtime-api.spec.ts
@@ -0,0 +1,885 @@
+/**
+ * OpenAI Realtime API Integration Tests
+ * Tests the WebSocket API behavior end-to-end
+ * 
+ * IMPORTANT: Before running these tests, start the WebSocket server:
+ *   1. Open a new terminal
+ *   2. cd to the serving/realtime-service/src directory
+ *   3. npm start
+ *   4. Wait for "Application Server listening on port 3001"
+ *   5. Then run: npm run test:api
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import * as RT from '../../src/types/realtime';
+import {
+  createWebSocketTestClient,
+  assertEvent,
+  createTextMessage,
+  createFunctionCallOutput,
+  waitForCompleteResponse,
+  extractTextFromResponse,
+  verifyContinuationAfterCancellation,
+  WebSocketTestClient,
+} from './websocket-test-helper';
+
+// Get port from environment variable
+const TEST_PORT = process.env.WS_APP_PORT ? parseInt(process.env.WS_APP_PORT) : 4000;
+
+describe('OpenAI Realtime API - Integration Tests', () => {
+  jest.setTimeout(60000); // 60 second timeout for API tests
+
+  describe('Session Management', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should create a session on connection and send session.created event', async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+
+      const sessionCreatedEvent = await client.waitForEvent('session.created', 5000);
+
+      assertEvent(sessionCreatedEvent, 'session.created', (event: RT.SessionCreatedEvent) => {
+        expect(event.session).toBeDefined();
+        expect(event.session.id).toBeDefined();
+        expect(event.session.type).toBe('realtime');
+        expect(event.session.object).toBe('realtime.session');
+        expect(event.session.model).toBeDefined();
+        expect(event.session.output_modalities).toEqual(expect.arrayContaining(['audio', 'text']));
+        expect(event.session.audio).toBeDefined();
+        expect(event.session.audio.input).toBeDefined();
+        expect(event.session.audio.output).toBeDefined();
+        expect(event.session.audio.output.voice).toBeDefined();
+        expect(event.session.instructions).toBeDefined();
+      });
+    });
+
+    it('should update session configuration via session.update', async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+
+      await client.waitForEvent('session.created');
+
+      const newInstructions = 'You are a helpful assistant that speaks like a pirate.';
+      const newVoice = 'TestVoice';
+
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          instructions: newInstructions,
+          audio: {
+            output: {
+              voice: newVoice,
+            },
+          },
+          temperature: 0.9,
+        },
+      });
+
+      const sessionUpdatedEvent = await client.waitForEvent('session.updated', 5000);
+
+      assertEvent(sessionUpdatedEvent, 'session.updated', (event: RT.SessionUpdatedEvent) => {
+        expect(event.session.instructions).toBe(newInstructions);
+        expect(event.session.audio.output.voice).toBe(newVoice);
+        expect(event.session.temperature).toBe(0.9);
+      });
+    });
+
+    it('should update turn detection settings', async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+
+      await client.waitForEvent('session.created');
+
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          audio: {
+            input: {
+              turn_detection: {
+                type: 'semantic_vad',
+                eagerness: 'high',
+                create_response: true,
+                interrupt_response: true,
+              },
+            },
+          },
+        },
+      });
+
+      const sessionUpdatedEvent = await client.waitForEvent('session.updated', 5000);
+
+      assertEvent(sessionUpdatedEvent, 'session.updated', (event: RT.SessionUpdatedEvent) => {
+        expect(event.session.audio.input.turn_detection).toBeDefined();
+        expect(event.session.audio.input.turn_detection?.type).toBe('semantic_vad');
+        if (event.session.audio.input.turn_detection?.type === 'semantic_vad') {
+          expect(event.session.audio.input.turn_detection.eagerness).toBe('high');
+        }
+      });
+    });
+  });
+
+  describe('Conversation Management', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    beforeEach(async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+      await client.waitForEvent('session.created');
+    });
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should create a conversation item and receive confirmation events', async () => {
+      const messageId = `msg-${uuidv4()}`;
+      const messageText = 'Hello, this is a test message.';
+
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage(messageText, 'user', messageId),
+      });
+
+      const events = await client.waitForEvents([
+        'conversation.item.added',
+        'conversation.item.done',
+      ], 5000);
+
+      const [addedEvent, doneEvent] = events;
+
+      assertEvent(addedEvent, 'conversation.item.added', (event: RT.ConversationItemAddedEvent) => {
+        expect(event.item.id).toBe(messageId);
+        expect(event.item.type).toBe('message');
+        expect(event.item.status).toBe('completed');
+      });
+
+      assertEvent(doneEvent, 'conversation.item.done', (event: RT.ConversationItemDoneEvent) => {
+        expect(event.item.id).toBe(messageId);
+      });
+    });
+
+    it('should retrieve a conversation item by ID', async () => {
+      const messageId = `msg-${uuidv4()}`;
+      const messageText = 'Test message for retrieval';
+
+      // Create item first
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage(messageText, 'user', messageId),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Retrieve the item
+      client.sendEvent({
+        type: 'conversation.item.retrieve',
+        item_id: messageId,
+      });
+
+      const retrievedEvent = await client.waitForEvent('conversation.item.retrieved', 5000);
+
+      assertEvent(retrievedEvent, 'conversation.item.retrieved', (event: RT.ConversationItemRetrievedEvent) => {
+        expect(event.item.id).toBe(messageId);
+        expect(event.item.type).toBe('message');
+      });
+    });
+
+    it('should delete a conversation item', async () => {
+      const messageId = `msg-${uuidv4()}`;
+
+      // Create item first
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Message to delete', 'user', messageId),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Delete the item
+      client.sendEvent({
+        type: 'conversation.item.delete',
+        item_id: messageId,
+      });
+
+      const deletedEvent = await client.waitForEvent('conversation.item.deleted', 5000);
+
+      assertEvent(deletedEvent, 'conversation.item.deleted', (event: RT.ConversationItemDeletedEvent) => {
+        expect(event.item_id).toBe(messageId);
+      });
+
+      // Verify item is gone by trying to retrieve it
+      client.sendEvent({
+        type: 'conversation.item.retrieve',
+        item_id: messageId,
+      });
+
+      const errorEvent = await client.waitForEvent('error', 5000);
+
+      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
+        expect(event.error.code).toBe('item_not_found');
+      });
+    });
+
+    it('should handle truncation of conversation items', async () => {
+      const messageId = `msg-${uuidv4()}`;
+
+      // Create an assistant message with audio (in real scenario)
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: {
+          type: 'message',
+          role: 'assistant',
+          id: messageId,
+          content: [
+            {
+              type: 'audio',
+              audio: 'base64audiodata',
+              transcript: 'This is a long message that will be truncated',
+            },
+          ],
+        } as RT.MessageItem,
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Truncate at 1000ms
+      client.sendEvent({
+        type: 'conversation.item.truncate',
+        item_id: messageId,
+        content_index: 0,
+        audio_end_ms: 1000,
+      });
+
+      const truncatedEvent = await client.waitForEvent('conversation.item.truncated', 5000);
+
+      assertEvent(truncatedEvent, 'conversation.item.truncated', (event: RT.ConversationItemTruncatedEvent) => {
+        expect(event.item_id).toBe(messageId);
+        expect(event.content_index).toBe(0);
+        expect(event.audio_end_ms).toBe(1000);
+      });
+    });
+
+    it('should return error when trying to retrieve non-existent item', async () => {
+      const nonExistentId = `msg-${uuidv4()}`;
+
+      client.sendEvent({
+        type: 'conversation.item.retrieve',
+        item_id: nonExistentId,
+      });
+
+      const errorEvent = await client.waitForEvent('error', 5000);
+
+      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
+        expect(event.error.type).toBe('invalid_request_error');
+        expect(event.error.code).toBe('item_not_found');
+        expect(event.error.message).toContain(nonExistentId);
+      });
+    });
+  });
+
+  describe('Response Generation', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    beforeEach(async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+      await client.waitForEvent('session.created');
+
+      // Set up session with text-only output for simpler testing
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          output_modalities: ['text'],
+          instructions: 'You are a helpful assistant. Keep responses brief.',
+        },
+      });
+
+      await client.waitForEvent('session.updated');
+    });
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should generate a response to a user message', async () => {
+      // Create user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Say hello', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      const response = await waitForCompleteResponse(client, 30000);
+
+      assertEvent(response.created, 'response.created', (event: RT.ResponseCreatedEvent) => {
+        expect(event.response.id).toBeDefined();
+        expect(event.response.status).toBe('in_progress');
+      });
+
+      assertEvent(response.done, 'response.done', (event: RT.ResponseDoneEvent) => {
+        expect(event.response.id).toBe(response.created.response.id);
+        expect(['completed', 'incomplete']).toContain(event.response.status);
+      });
+
+      // Verify we got text output
+      const text = extractTextFromResponse(response.allEvents);
+      expect(text.length).toBeGreaterThan(0);
+    });
+
+    it('should emit response events in correct order', async () => {
+      // Create user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Count to three', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      const response = await waitForCompleteResponse(client, 30000);
+
+      const eventTypes = response.allEvents.map(e => e.type);
+
+      // Verify event ordering
+      const createdIndex = eventTypes.indexOf('response.created');
+      const doneIndex = eventTypes.indexOf('response.done');
+
+      expect(createdIndex).toBeGreaterThanOrEqual(0);
+      expect(doneIndex).toBeGreaterThan(createdIndex);
+
+      // All response-related events should be between created and done
+      const betweenEvents = eventTypes.slice(createdIndex + 1, doneIndex);
+      betweenEvents.forEach(type => {
+        expect(type).toMatch(/^(response\.|conversation\.item)/);
+      });
+    });
+
+    it('should cancel response immediately after creation', async () => {
+      // Create user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Tell me a long story', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      // Wait for response to start
+      const createdEvent = await client.waitForEvent('response.created', 5000);
+      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
+
+      // Cancel immediately after creation
+      client.sendEvent({
+        type: 'response.cancel',
+        response_id: responseId,
+      });
+
+      // Wait for response.done with cancelled status
+      const doneEvent = await client.waitForEvent('response.done', 10000);
+
+      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
+        expect(event.response.id).toBe(responseId);
+        expect(event.response.status).toBe('cancelled');
+        expect(event.response.status_details?.type).toBe('cancelled');
+        expect(event.response.status_details?.reason).toBe('client_cancelled');
+      });
+
+      // Verify conversation continues to work after cancellation
+      await verifyContinuationAfterCancellation(client, responseId, 'Say hello');
+    });
+
+    it('should cancel response after first text delta', async () => {
+      // Create user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Tell me a story', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response (text-only mode already set in session)
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      // Wait for response to start
+      const createdEvent = await client.waitForEvent('response.created', 5000);
+      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
+
+      // Wait for first text delta (using correct event type: response.output_text.delta)
+      const firstDelta = await client.waitForEvent('response.output_text.delta', 10000);
+      expect(firstDelta).toBeDefined();
+
+      // Cancel after receiving first delta
+      client.sendEvent({
+        type: 'response.cancel',
+        response_id: responseId,
+      });
+
+      // Wait for response.done with cancelled status
+      const doneEvent = await client.waitForEvent('response.done', 10000);
+
+      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
+        expect(event.response.id).toBe(responseId);
+        expect(event.response.status).toBe('cancelled');
+        expect(event.response.status_details?.type).toBe('cancelled');
+        expect(event.response.status_details?.reason).toBe('client_cancelled');
+        // Response should have at least one output item with some content
+        expect(event.response.output.length).toBeGreaterThan(0);
+      });
+
+      // Verify conversation continues to work after cancellation
+      await verifyContinuationAfterCancellation(client, responseId, 'Say goodbye');
+    });
+
+    it('should cancel response during audio streaming', async () => {
+      // Update session to enable audio output
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          output_modalities: ['audio', 'text'],
+          instructions: 'You are a helpful assistant. Provide detailed responses.',
+        },
+      });
+
+      await client.waitForEvent('session.updated');
+
+      // Create user message with a prompt that will generate a longer response
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Hello', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response with audio output
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      // Wait for response to start
+      const createdEvent = await client.waitForEvent('response.created', 5000);
+      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
+
+      // Wait for audio to start streaming (using correct event type: response.output_audio.delta)
+      await client.waitForEvent('response.output_audio.delta', 10000);
+
+      // Cancel during audio streaming
+      client.sendEvent({
+        type: 'response.cancel',
+        response_id: responseId,
+      });
+
+      // Wait for response.done with cancelled status
+      const doneEvent = await client.waitForEvent('response.done', 10000);
+
+      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
+        expect(event.response.id).toBe(responseId);
+        expect(event.response.status).toBe('cancelled');
+        expect(event.response.status_details?.type).toBe('cancelled');
+        expect(event.response.status_details?.reason).toBe('client_cancelled');
+      });
+
+      // Verify conversation continues to work after cancellation
+      await verifyContinuationAfterCancellation(client, responseId, 'Hi again');
+    });
+
+    it.skip('should cancel response during long audio/text streaming', async () => {
+      // Update session to enable audio output
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          output_modalities: ['audio', 'text'],
+          instructions: 'You are a helpful assistant. Provide detailed responses.',
+        },
+      });
+
+      await client.waitForEvent('session.updated');
+
+      // Create user message with a prompt that will generate a longer response
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Tell me a detailed story about space exploration with multiple paragraphs', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response with audio output
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      // Wait for response to start
+      const createdEvent = await client.waitForEvent('response.created', 5000);
+      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
+
+      // Wait for audio to start streaming (using correct event type: response.output_audio.delta)
+      await client.waitForEvent('response.output_audio.delta', 10000);
+
+      // Wait just a moment to ensure we're mid-stream (but not so long that response completes)
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Cancel during audio streaming
+      client.sendEvent({
+        type: 'response.cancel',
+        response_id: responseId,
+      });
+
+      // Wait for response.done with cancelled status
+      const doneEvent = await client.waitForEvent('response.done', 10000);
+
+      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
+        expect(event.response.id).toBe(responseId);
+        expect(event.response.status).toBe('cancelled');
+        expect(event.response.status_details?.type).toBe('cancelled');
+        expect(event.response.status_details?.reason).toBe('client_cancelled');
+      });
+
+      // Verify conversation continues to work after cancellation
+      await verifyContinuationAfterCancellation(client, responseId, 'What is 2+2?');
+    });
+
+    it('should include usage information in response', async () => {
+      // Create user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('Hello', 'user'),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Request response
+      client.sendEvent({
+        type: 'response.create',
+      });
+
+      const response = await waitForCompleteResponse(client, 30000);
+
+      assertEvent(response.done, 'response.done', (event: RT.ResponseDoneEvent) => {
+        // Usage might be present (depending on implementation)
+        if (event.response.usage) {
+          expect(event.response.usage.total_tokens).toBeGreaterThan(0);
+          expect(event.response.usage.input_tokens).toBeGreaterThanOrEqual(0);
+          expect(event.response.usage.output_tokens).toBeGreaterThan(0);
+        }
+      });
+    });
+  });
+
+  describe('Function Calling', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    beforeEach(async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+      await client.waitForEvent('session.created');
+
+      // Configure session with function tools
+      client.sendEvent({
+        type: 'session.update',
+        session: {
+          output_modalities: ['text'],
+          instructions: 'You are a helpful assistant with access to tools.',
+          tools: [
+            {
+              type: 'function',
+              name: 'get_weather',
+              description: 'Get the current weather for a location',
+              parameters: {
+                type: 'object',
+                properties: {
+                  location: {
+                    type: 'string',
+                    description: 'The city and state, e.g. San Francisco, CA',
+                  },
+                },
+                required: ['location'],
+              },
+            },
+          ],
+          tool_choice: 'auto',
+        },
+      });
+
+      await client.waitForEvent('session.updated');
+    });
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should handle function call output', async () => {
+      const callId = `call-${uuidv4()}`;
+      const functionOutput = JSON.stringify({
+        temperature: 72,
+        condition: 'sunny',
+      });
+
+      // Create function output item
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createFunctionCallOutput(callId, functionOutput),
+      });
+
+      const events = await client.waitForEvents([
+        'conversation.item.added',
+        'conversation.item.done',
+      ], 5000);
+
+      assertEvent(events[0], 'conversation.item.added', (event: RT.ConversationItemAddedEvent) => {
+        expect(event.item.type).toBe('function_call_output');
+        const item = event.item as RT.FunctionCallOutputItem;
+        expect(item.call_id).toBe(callId);
+        expect(item.output).toBe(functionOutput);
+      });
+    });
+  });
+
+  describe('Audio Input Management', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    beforeEach(async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+      await client.waitForEvent('session.created');
+    });
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should handle input audio buffer clear', async () => {
+      // Append some audio data first
+      client.sendEvent({
+        type: 'input_audio_buffer.append',
+        audio: 'YmFzZTY0ZW5jb2RlZGF1ZGlv', // base64 encoded dummy data
+      });
+
+      // Give it a moment to process
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Clear the buffer
+      client.sendEvent({
+        type: 'input_audio_buffer.clear',
+      });
+
+      const clearedEvent = await client.waitForEvent('input_audio_buffer.cleared', 5000);
+
+      assertEvent(clearedEvent, 'input_audio_buffer.cleared');
+    });
+
+    // TODO: This test times out - audio buffer commit may require actual audio data or STT setup
+    it.skip('should handle input audio buffer commit', async () => {
+      // NOTE: This test is currently skipped because it requires:
+      // - Proper audio data (not just base64 dummy data)
+      // - Speech-to-text service to be properly configured
+      // - AssemblyAI or other STT provider setup
+
+      // Append audio data
+      client.sendEvent({
+        type: 'input_audio_buffer.append',
+        audio: 'YmFzZTY0ZW5jb2RlZGF1ZGlv',
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Commit the buffer
+      client.sendEvent({
+        type: 'input_audio_buffer.commit',
+      });
+
+      const committedEvent = await client.waitForEvent('input_audio_buffer.committed', 30000);
+
+      assertEvent(committedEvent, 'input_audio_buffer.committed', (event: RT.InputAudioBufferCommittedEvent) => {
+        expect(event.item_id).toBeDefined();
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    let client: WebSocketTestClient;
+    const sessionKey = `test-session-${uuidv4()}`;
+
+    beforeEach(async () => {
+      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
+      await client.waitForEvent('session.created');
+    });
+
+    afterEach(async () => {
+      if (client) {
+        await client.close();
+      }
+    });
+
+    it('should return error for invalid event format', async () => {
+      // Send malformed JSON
+      client.ws.send('{ invalid json }');
+
+      const errorEvent = await client.waitForEvent('error', 5000);
+
+      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
+        expect(event.error.type).toBe('invalid_request_error');
+      });
+    });
+
+    it('should return error when truncating user message', async () => {
+      const messageId = `msg-${uuidv4()}`;
+
+      // Create a user message
+      client.sendEvent({
+        type: 'conversation.item.create',
+        item: createTextMessage('User message', 'user', messageId),
+      });
+
+      await client.waitForEvent('conversation.item.done');
+
+      // Try to truncate (only assistant messages can be truncated)
+      client.sendEvent({
+        type: 'conversation.item.truncate',
+        item_id: messageId,
+        content_index: 0,
+        audio_end_ms: 1000,
+      });
+
+      const errorEvent = await client.waitForEvent('error', 5000);
+
+      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
+        expect(event.error.type).toBe('invalid_request_error');
+        expect(event.error.code).toBe('invalid_item_type');
+      });
+    });
+  });
+
+  describe('Multi-Session Support', () => {
+    it('should handle multiple concurrent sessions', async () => {
+      const session1Key = `test-session-${uuidv4()}`;
+      const session2Key = `test-session-${uuidv4()}`;
+
+      const client1 = await createWebSocketTestClient(session1Key, TEST_PORT);
+      const client2 = await createWebSocketTestClient(session2Key, TEST_PORT);
+
+      try {
+        // Wait for both sessions to be created
+        const [session1Created, session2Created] = await Promise.all([
+          client1.waitForEvent('session.created'),
+          client2.waitForEvent('session.created'),
+        ]);
+
+        // Verify they have different session IDs
+        const s1 = session1Created as RT.SessionCreatedEvent;
+        const s2 = session2Created as RT.SessionCreatedEvent;
+        expect(s1.session.id).not.toBe(s2.session.id);
+
+        // Configure sessions differently
+        client1.sendEvent({
+          type: 'session.update',
+          session: {
+            instructions: 'You are session 1',
+            temperature: 0.5,
+          },
+        });
+
+        client2.sendEvent({
+          type: 'session.update',
+          session: {
+            instructions: 'You are session 2',
+            temperature: 0.9,
+          },
+        });
+
+        const [updated1, updated2] = await Promise.all([
+          client1.waitForEvent('session.updated'),
+          client2.waitForEvent('session.updated'),
+        ]);
+
+        // Verify each session kept its own configuration
+        const u1 = updated1 as RT.SessionUpdatedEvent;
+        const u2 = updated2 as RT.SessionUpdatedEvent;
+        expect(u1.session.instructions).toBe('You are session 1');
+        expect(u1.session.temperature).toBe(0.5);
+        expect(u2.session.instructions).toBe('You are session 2');
+        expect(u2.session.temperature).toBe(0.9);
+      } finally {
+        await client1.close();
+        await client2.close();
+      }
+    });
+  });
+
+  describe('Workspace Isolation', () => {
+    it('should isolate sessions by workspace', async () => {
+      const sessionKey = `test-session-${uuidv4()}`;
+      const workspace1 = `workspace-${uuidv4()}`;
+      const workspace2 = `workspace-${uuidv4()}`;
+
+      const client1 = await createWebSocketTestClient(sessionKey, TEST_PORT, workspace1);
+      const client2 = await createWebSocketTestClient(sessionKey, TEST_PORT, workspace2);
+
+      try {
+        // Both sessions should be created successfully with same key but different workspaces
+        await Promise.all([
+          client1.waitForEvent('session.created'),
+          client2.waitForEvent('session.created'),
+        ]);
+
+        // They should operate independently
+        client1.sendEvent({
+          type: 'session.update',
+          session: {
+            instructions: 'Workspace 1 instructions',
+          },
+        });
+
+        const updated1 = await client1.waitForEvent('session.updated');
+
+        // Verify workspace 1 has its instructions
+        const u1 = updated1 as RT.SessionUpdatedEvent;
+        expect(u1.session.instructions).toBe('Workspace 1 instructions');
+
+        // Workspace 2 should still have default instructions
+        // (we'll verify by updating workspace 2 and checking it didn't get workspace 1's instructions)
+        client2.sendEvent({
+          type: 'session.update',
+          session: {
+            instructions: 'Workspace 2 instructions',
+          },
+        });
+
+        const updated2 = await client2.waitForEvent('session.updated');
+        const u2 = updated2 as RT.SessionUpdatedEvent;
+        expect(u2.session.instructions).toBe('Workspace 2 instructions');
+        expect(u2.session.instructions).not.toBe(u1.session.instructions);
+      } finally {
+        await client1.close();
+        await client2.close();
+      }
+    });
+  });
+});
+
diff --git a/realtime-service/__tests__/api/websocket-server-helper.ts b/realtime-service/__tests__/api/websocket-server-helper.ts
new file mode 100644
index 0000000..c1daa62
--- /dev/null
+++ b/realtime-service/__tests__/api/websocket-server-helper.ts
@@ -0,0 +1,133 @@
+/**
+ * WebSocket Server Helper
+ * Manages the WebSocket server lifecycle for integration tests
+ */
+
+import { ChildProcess, spawn } from 'child_process';
+import WebSocket from 'ws';
+
+let serverProcess: ChildProcess | null = null;
+let serverPort: number = 3001;
+
+/**
+ * Start the WebSocket server for testing
+ */
+export async function startTestServer(port: number = 3001): Promise<number> {
+  if (serverProcess) {
+    return serverPort;
+  }
+
+  serverPort = port;
+
+  return new Promise((resolve, reject) => {
+    // Start the server process from the src directory
+    const srcDir = __dirname + '/../../src';
+    serverProcess = spawn('npm', ['start'], {
+      cwd: srcDir,
+      env: {
+        ...process.env,
+        WS_APP_PORT: String(port),
+        AUTH_TOKEN: '', // Disable auth for tests
+        NODE_ENV: 'test',
+      },
+      stdio: 'ignore', // Ignore stdio to prevent blocking
+      detached: true, // Detach so it doesn't block Jest
+    });
+    
+    // Unref so the parent process can exit without waiting
+    serverProcess.unref();
+
+    // Wait for server to be ready by attempting to connect
+    const startTime = Date.now();
+    const maxWait = 15000; // 15 seconds
+    
+    const checkServer = async (): Promise<void> => {
+      while (Date.now() - startTime < maxWait) {
+        try {
+          await waitForServerReady(port, 1);
+          resolve(port);
+          return;
+        } catch (error) {
+          // Server not ready yet, wait a bit
+          await new Promise(r => setTimeout(r, 500));
+        }
+      }
+      reject(new Error('Server startup timeout'));
+    };
+    
+    checkServer().catch(reject);
+  });
+}
+
+/**
+ * Stop the WebSocket server
+ */
+export async function stopTestServer(): Promise<void> {
+  if (!serverProcess) {
+    return;
+  }
+
+  return new Promise((resolve) => {
+    const process = serverProcess!;
+    serverProcess = null;
+
+    process.on('exit', () => {
+      resolve();
+    });
+
+    process.kill('SIGTERM');
+
+    // Force kill after 5 seconds
+    setTimeout(() => {
+      if (!process.killed) {
+        process.kill('SIGKILL');
+        resolve();
+      }
+    }, 5000);
+  });
+}
+
+/**
+ * Wait for server to be ready by attempting to connect
+ */
+export async function waitForServerReady(port: number, maxAttempts: number = 20): Promise<void> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const ws = new WebSocket(`ws://localhost:${port}/session?key=test-health-check`);
+        
+        const timeout = setTimeout(() => {
+          ws.close();
+          reject(new Error('Connection timeout'));
+        }, 1000);
+
+        ws.on('open', () => {
+          clearTimeout(timeout);
+          ws.close();
+          resolve();
+        });
+
+        ws.on('error', () => {
+          clearTimeout(timeout);
+          reject(new Error('Connection failed'));
+        });
+      });
+
+      // Server is ready
+      return;
+    } catch (error) {
+      // Wait before retrying
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  }
+
+  throw new Error('Server failed to become ready');
+}
+
+/**
+ * Get the current server port
+ */
+export function getServerPort(): number {
+  return serverPort;
+}
+
diff --git a/realtime-service/__tests__/api/websocket-test-helper.ts b/realtime-service/__tests__/api/websocket-test-helper.ts
new file mode 100644
index 0000000..ce7b207
--- /dev/null
+++ b/realtime-service/__tests__/api/websocket-test-helper.ts
@@ -0,0 +1,311 @@
+/**
+ * WebSocket API Test Helper
+ * Provides utilities for testing the WebSocket Realtime API
+ */
+
+import WebSocket from 'ws';
+import * as RT from '../../src/types/realtime';
+
+export interface WebSocketTestClient {
+  ws: WebSocket;
+  events: RT.ServerEvent[];
+  waitForEvent: (eventType: string, timeout?: number) => Promise<RT.ServerEvent>;
+  waitForEvents: (eventTypes: string[], timeout?: number) => Promise<RT.ServerEvent[]>;
+  sendEvent: (event: RT.ClientEvent) => void;
+  clearEvents: () => void;
+  close: () => Promise<void>;
+}
+
+/**
+ * Create a WebSocket test client that connects to the realtime service
+ */
+export async function createWebSocketTestClient(
+  sessionKey: string,
+  port: number = 3001,
+  workspaceId?: string
+): Promise<WebSocketTestClient> {
+  const options: any = {};
+  if (workspaceId) {
+    options.headers = {
+      'workspace-id': workspaceId,
+    };
+  }
+
+  const ws = new WebSocket(`ws://localhost:${port}/session?key=${sessionKey}`, options);
+
+  const events: RT.ServerEvent[] = [];
+  const eventPromises = new Map<string, Array<(event: RT.ServerEvent) => void>>();
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error(
+        `WebSocket connection timeout. ` +
+        `Make sure the server is running: cd src && npm start`
+      ));
+    }, 5000);
+
+    ws.on('open', () => {
+      clearTimeout(timeout);
+
+      const client: WebSocketTestClient = {
+        ws,
+        events,
+
+        waitForEvent: (eventType: string, timeout = 5000): Promise<RT.ServerEvent> => {
+          // Check if event already received
+          const existingEvent = events.find(e => e.type === eventType);
+          if (existingEvent) {
+            return Promise.resolve(existingEvent);
+          }
+
+          // Wait for new event
+          return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+              reject(new Error(`Timeout waiting for event: ${eventType}`));
+            }, timeout);
+
+            if (!eventPromises.has(eventType)) {
+              eventPromises.set(eventType, []);
+            }
+
+            eventPromises.get(eventType)!.push((event) => {
+              clearTimeout(timeoutId);
+              resolve(event);
+            });
+          });
+        },
+
+        waitForEvents: async (eventTypes: string[], timeout = 5000): Promise<RT.ServerEvent[]> => {
+          const results: RT.ServerEvent[] = [];
+          const startTime = Date.now();
+
+          for (const eventType of eventTypes) {
+            const remainingTime = timeout - (Date.now() - startTime);
+            if (remainingTime <= 0) {
+              throw new Error(`Timeout waiting for events: ${eventTypes.join(', ')}`);
+            }
+
+            const event = await client.waitForEvent(eventType, remainingTime);
+            results.push(event);
+          }
+
+          return results;
+        },
+
+        sendEvent: (event: RT.ClientEvent): void => {
+          ws.send(JSON.stringify(event));
+        },
+
+        clearEvents: (): void => {
+          events.length = 0;
+        },
+
+        close: (): Promise<void> => {
+          return new Promise((resolve) => {
+            ws.once('close', () => resolve());
+            ws.close();
+          });
+        },
+      };
+
+      resolve(client);
+    });
+
+    ws.on('message', (data: any) => {
+      try {
+        const event = JSON.parse(data.toString()) as RT.ServerEvent;
+        events.push(event);
+
+        // Resolve any waiting promises for this event type
+        const waiters = eventPromises.get(event.type);
+        if (waiters && waiters.length > 0) {
+          const waiter = waiters.shift()!;
+          waiter(event);
+        }
+      } catch (error) {
+        console.error('Failed to parse WebSocket message:', error);
+      }
+    });
+
+    ws.on('error', (error) => {
+      clearTimeout(timeout);
+      reject(new Error(
+        `WebSocket connection failed: ${error.message}\n` +
+        `\n` +
+        `Make sure the server is running on port ${port}:\n` +
+        `  1. Open a new terminal\n` +
+        `  2. cd <path-to-project>/serving/realtime-service/src\n` +
+        `  3. npm start\n` +
+        `  4. Wait for "Application Server listening on port ${port}"\n` +
+        `  5. Then run: npm run test:api`
+      ));
+    });
+  });
+}
+
+/**
+ * Helper to collect all events until a specific event type is received
+ */
+export async function collectEventsUntil(
+  client: WebSocketTestClient,
+  untilEventType: string,
+  timeout: number = 5000
+): Promise<RT.ServerEvent[]> {
+  const startLength = client.events.length;
+  await client.waitForEvent(untilEventType, timeout);
+  return client.events.slice(startLength);
+}
+
+/**
+ * Assert that an event matches expected properties
+ */
+export function assertEvent(
+  event: RT.ServerEvent,
+  expectedType: string,
+  additionalChecks?: (event: any) => void
+): void {
+  expect(event.type).toBe(expectedType);
+  expect(event.event_id).toBeDefined();
+  
+  if (additionalChecks) {
+    additionalChecks(event);
+  }
+}
+
+/**
+ * Create a text message conversation item
+ */
+export function createTextMessage(
+  text: string,
+  role: 'user' | 'assistant' | 'system' = 'user',
+  id?: string
+): RT.MessageItem {
+  return {
+    type: 'message',
+    role,
+    content: [
+      {
+        type: 'input_text',
+        text,
+      },
+    ],
+    ...(id && { id }),
+  };
+}
+
+/**
+ * Create a function call output item
+ */
+export function createFunctionCallOutput(
+  callId: string,
+  output: string,
+  id?: string
+): RT.FunctionCallOutputItem {
+  return {
+    type: 'function_call_output',
+    call_id: callId,
+    output,
+    ...(id && { id }),
+  };
+}
+
+/**
+ * Wait for a complete response (from response.created to response.done)
+ */
+export async function waitForCompleteResponse(
+  client: WebSocketTestClient,
+  timeout: number = 30000
+): Promise<{
+  created: RT.ResponseCreatedEvent;
+  done: RT.ResponseDoneEvent;
+  allEvents: RT.ServerEvent[];
+}> {
+  const startLength = client.events.length;
+  
+  const created = await client.waitForEvent('response.created', timeout);
+  const done = await client.waitForEvent('response.done', timeout);
+  
+  const allEvents = client.events.slice(startLength);
+  
+  return {
+    created: created as RT.ResponseCreatedEvent,
+    done: done as RT.ResponseDoneEvent,
+    allEvents,
+  };
+}
+
+/**
+ * Extract text content from a response
+ */
+export function extractTextFromResponse(events: RT.ServerEvent[]): string {
+  let text = '';
+  
+  for (const event of events) {
+    if (event.type === 'response.output_text.delta') {
+      const deltaEvent = event as RT.ResponseTextDeltaEvent;
+      text += deltaEvent.delta;
+    }
+  }
+  
+  return text;
+}
+
+/**
+ * Extract audio transcript from a response
+ */
+export function extractAudioTranscriptFromResponse(events: RT.ServerEvent[]): string {
+  let transcript = '';
+  
+  for (const event of events) {
+    if (event.type === 'response.output_audio_transcript.delta') {
+      const deltaEvent = event as RT.ResponseAudioTranscriptDeltaEvent;
+      transcript += deltaEvent.delta;
+    }
+  }
+  
+  return transcript;
+}
+
+/**
+ * Verify that a new conversation request works after cancellation
+ */
+export async function verifyContinuationAfterCancellation(
+  client: WebSocketTestClient,
+  originalResponseId: string,
+  newMessageText: string,
+): Promise<void> {
+  // Clear events to ensure we wait for NEW response events
+  client.clearEvents();
+
+  // Verify we can send a new conversation request after cancellation
+  client.sendEvent({
+    type: 'conversation.item.create',
+    item: createTextMessage(newMessageText, 'user'),
+  });
+
+  await client.waitForEvent('conversation.item.done');
+
+  client.sendEvent({
+    type: 'response.create',
+  });
+
+  const newResponse = await waitForCompleteResponse(client, 30000);
+
+  assertEvent(newResponse.created, 'response.created', (event: RT.ResponseCreatedEvent) => {
+    expect(event.response.id).toBeDefined();
+    expect(event.response.id).not.toBe(originalResponseId);
+    expect(event.response.status).toBe('in_progress');
+  });
+
+  assertEvent(newResponse.done, 'response.done', (event: RT.ResponseDoneEvent) => {
+    expect(['completed', 'incomplete']).toContain(event.response.status);
+  });
+
+  // Verify we got some output in the new response
+  const hasOutput = newResponse.allEvents.some(
+    e => e.type === 'response.output_text.delta' || e.type === 'response.output_audio.delta'
+  );
+  expect(hasOutput).toBe(true);
+}
+
diff --git a/realtime-service/__tests__/config.ts b/realtime-service/__tests__/config.ts
new file mode 100644
index 0000000..47f9d44
--- /dev/null
+++ b/realtime-service/__tests__/config.ts
@@ -0,0 +1,8 @@
+/**
+ * Test configuration constants
+ */
+
+export const TEST_SESSION_ID = 'test-session-123';
+export const TEST_INTERACTION_ID = 'test-interaction-456';
+export const TEST_WORKSPACE_ID = 'test-workspace-789';
+
diff --git a/realtime-service/__tests__/setup.ts b/realtime-service/__tests__/setup.ts
new file mode 100644
index 0000000..acc86f6
--- /dev/null
+++ b/realtime-service/__tests__/setup.ts
@@ -0,0 +1,9 @@
+/**
+ * Jest setup file
+ * This file runs before all tests and sets up the testing environment
+ */
+
+import * as dotenv from 'dotenv';
+
+// Load test environment variables from root .env.test
+dotenv.config({ path: './.env.test' });
diff --git a/realtime-service/__tests__/test-setup.ts b/realtime-service/__tests__/test-setup.ts
new file mode 100644
index 0000000..682ad56
--- /dev/null
+++ b/realtime-service/__tests__/test-setup.ts
@@ -0,0 +1,32 @@
+/**
+ * Jest setupFilesAfterEnv configuration
+ * This runs after the test framework is installed
+ */
+
+// Mock the logger to prevent console output during tests
+jest.mock('../src/logger', () => ({
+  default: {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    trace: jest.fn(),
+    fatal: jest.fn(),
+  },
+}));
+
+// Mock log-helpers
+jest.mock('../src/log-helpers', () => ({
+  formatContext: jest.fn((context: any) => JSON.stringify(context)),
+  formatSession: jest.fn((session: any) => JSON.stringify(session)),
+  formatWorkspace: jest.fn((workspace: any) => JSON.stringify(workspace)),
+}));
+
+// Set up common test behaviors
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+// Global test timeout
+jest.setTimeout(30000);
+
diff --git a/realtime-service/__tests__/utils/graph-test-helpers.ts b/realtime-service/__tests__/utils/graph-test-helpers.ts
new file mode 100644
index 0000000..efc24db
--- /dev/null
+++ b/realtime-service/__tests__/utils/graph-test-helpers.ts
@@ -0,0 +1,71 @@
+/**
+ * Helper utilities for testing graph-related components
+ */
+
+import { GraphBuilder } from '@inworld/runtime/graph';
+
+/**
+ * Creates a mock GraphBuilder for testing
+ */
+export function createMockGraphBuilder(graphId: string = 'test-graph') {
+  const nodes: any[] = [];
+  const edges: any[] = [];
+
+  const builder = {
+    addNode: jest.fn((node: any) => {
+      nodes.push(node);
+      return builder;
+    }),
+    addEdge: jest.fn((from: any, to: any, options?: any) => {
+      edges.push({ from, to, options });
+      return builder;
+    }),
+    setStartNode: jest.fn((node: any) => {
+      return builder;
+    }),
+    setEndNode: jest.fn((node: any) => {
+      return builder;
+    }),
+    build: jest.fn(() => ({
+      id: graphId,
+      nodes,
+      edges,
+      start: jest.fn(),
+      stop: jest.fn(),
+      execute: jest.fn(),
+    })),
+  };
+
+  return builder;
+}
+
+/**
+ * Creates a mock Graph instance
+ */
+export function createMockGraph(graphId: string = 'test-graph') {
+  return {
+    id: graphId,
+    start: jest.fn().mockResolvedValue(undefined),
+    stop: jest.fn().mockResolvedValue(undefined),
+    execute: jest.fn().mockResolvedValue(undefined),
+    getNodeById: jest.fn(),
+    getAllNodes: jest.fn(() => []),
+  };
+}
+
+/**
+ * Helper to wait for async operations in tests
+ */
+export async function waitForAsync(ms: number = 0): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Helper to create a mock async iterator for streaming data
+ */
+export async function* createMockAsyncIterator<T>(items: T[]): AsyncIterableIterator<T> {
+  for (const item of items) {
+    yield item;
+  }
+}
+
diff --git a/realtime-service/__tests__/utils/mock-helpers.ts b/realtime-service/__tests__/utils/mock-helpers.ts
new file mode 100644
index 0000000..73fd89d
--- /dev/null
+++ b/realtime-service/__tests__/utils/mock-helpers.ts
@@ -0,0 +1,93 @@
+/**
+ * Mock helpers for unit tests
+ * These utilities help create mock objects for testing
+ */
+
+import { ProcessContext } from '@inworld/runtime/graph';
+import { ConnectionsMap, State, Connection } from '../../types/index';
+
+/**
+ * Creates a mock ProcessContext for testing
+ */
+export function createMockProcessContext(datastoreData: Record<string, any> = {}): ProcessContext {
+  const datastore = new Map(Object.entries(datastoreData));
+  
+  return {
+    getDatastore: jest.fn(() => ({
+      get: jest.fn((key: string) => datastore.get(key)),
+      set: jest.fn((key: string, value: any) => datastore.set(key, value)),
+      has: jest.fn((key: string) => datastore.has(key)),
+      delete: jest.fn((key: string) => datastore.delete(key)),
+    })),
+    getNodeId: jest.fn(() => 'test-node-id'),
+    getGraphId: jest.fn(() => 'test-graph-id'),
+  } as any;
+}
+
+/**
+ * Creates a mock State object for testing
+ */
+export function createMockState(overrides: Partial<State> = {}): State {
+  return {
+    sessionId: overrides.sessionId || 'test-session-id',
+    interactionId: overrides.interactionId || 'test-interaction-id',
+    messages: overrides.messages || [],
+    eagerness: overrides.eagerness || 'medium',
+    ...overrides,
+  } as State;
+}
+
+/**
+ * Creates a mock Connection object for testing
+ */
+export function createMockConnection(
+  sessionId: string = 'test-session-id',
+  stateOverrides: Partial<State> = {}
+): Connection {
+  return {
+    sessionId,
+    state: createMockState({ sessionId, ...stateOverrides }),
+    unloaded: false,
+  } as Connection;
+}
+
+/**
+ * Creates a mock ConnectionsMap for testing
+ */
+export function createMockConnectionsMap(
+  sessions: string[] = ['test-session-id']
+): ConnectionsMap {
+  const connections: ConnectionsMap = {};
+  
+  sessions.forEach(sessionId => {
+    connections[sessionId] = createMockConnection(sessionId);
+  });
+  
+  return connections;
+}
+
+/**
+ * Creates a mock DataStreamWithMetadata for testing
+ */
+export function createMockDataStreamWithMetadata(metadata: Record<string, any> = {}) {
+  return {
+    getMetadata: jest.fn(() => metadata),
+    getData: jest.fn(() => Buffer.from('test-data')),
+    setMetadata: jest.fn(),
+  };
+}
+
+/**
+ * Helper to create a spy on a logger
+ */
+export function createLoggerSpy() {
+  return {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    trace: jest.fn(),
+    fatal: jest.fn(),
+  };
+}
+
diff --git a/realtime-service/jest.config.js b/realtime-service/jest.config.js
new file mode 100644
index 0000000..6865b24
--- /dev/null
+++ b/realtime-service/jest.config.js
@@ -0,0 +1,34 @@
+module.exports = {
+  clearMocks: true,
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testTimeout: 30000,
+  roots: ['<rootDir>/__tests__'],
+  testMatch: [
+    '**/__tests__/**/*.spec.ts',
+    '**/?(*.)+(spec).ts'
+  ],
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      tsconfig: 'tsconfig.test.json'
+    }]
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/dist/**',
+    '!src/node_modules/**',
+    '!src/index.ts',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  coveragePathIgnorePatterns: ['node_modules', 'dist', '__tests__'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+  setupFiles: ['<rootDir>/__tests__/setup.ts'],
+  setupFilesAfterEnv: ['<rootDir>/__tests__/test-setup.ts'],
+  modulePathIgnorePatterns: ['dist/', 'node_modules/'],
+  verbose: true,
+};
diff --git a/realtime-service/load-tests/README.md b/realtime-service/load-tests/README.md
new file mode 100644
index 0000000..3f10757
--- /dev/null
+++ b/realtime-service/load-tests/README.md
@@ -0,0 +1,61 @@
+# Load Tests
+
+Load testing suite for the Inworld Realtime API service using k6.
+
+## Prerequisites
+
+- [k6](https://k6.io/docs/getting-started/installation/) installed
+
+## Available Test Scripts
+
+### Local Mock Environment
+- `npm run test:local:mock:small` - Small load test
+- `npm run test:local:mock:medium` - Medium load test
+- `npm run test:local:mock:large` - Large load test
+- `npm run test:local:mock:xlarge` - Extra large load test
+
+### Local Proxy Environment
+- `npm run test:local:proxy:small` - Small load test
+- `npm run test:local:proxy:medium` - Medium load test
+- `npm run test:local:proxy:large` - Large load test
+- `npm run test:local:proxy:xlarge` - Extra large load test
+
+### Local Realtime Service
+- `npm run test:local:realtime:small` - Small load test
+- `npm run test:local:realtime:medium` - Medium load test
+- `npm run test:local:realtime:xmedium` - Extra medium load test
+- `npm run test:local:realtime:x2medium` - 2x medium load test
+- `npm run test:local:realtime:x2mediumLong` - 2x medium long duration test
+- `npm run test:local:realtime:large` - Large load test
+- `npm run test:local:realtime:xlarge` - Extra large load test
+
+### Dev Environment
+- `npm run test:dev:realtime:small` - Small load test
+- `npm run test:dev:realtime:medium` - Medium load test
+- `npm run test:dev:realtime:large` - Large load test
+- `npm run test:dev:realtime:xlarge` - Extra large load test
+
+## Environment Variables
+
+- `INWORLD_API_KEY` - Base64 encoded API key for authentication (optional)
+- `ENV_NAME` - Target environment (local-mock, local-proxy, local-realtime, dev)
+- `SCENARIO` - Load scenario (small, medium, large, xlarge, etc.)
+- `USE_ITEM_DONE_FOR_LATENCY` - Use response.done for latency measurement for response.create (true/false)
+- `WAIT_FOR_RESPONSE` - Wait for response before sending next message (true/false)
+- `DEBUG` - Enable debug logging (true/false)
+- `USE_WORKSPACE_PER_VU` - Enable propagate `workspace-id` unique header per VU
+
+## Usage
+
+Run a test script:
+```bash
+npm run test:local:realtime:medium
+```
+
+Or run k6 directly with custom parameters:
+```bash
+k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=medium
+```
+
+For local load testing or for direct Realtime service testing, you can use env variable `USE_WORKSPACE_PER_VU=true`
+to emulate multiple workspace's requests.
diff --git a/realtime-service/load-tests/load_test.js b/realtime-service/load-tests/load_test.js
new file mode 100644
index 0000000..b249d6e
--- /dev/null
+++ b/realtime-service/load-tests/load_test.js
@@ -0,0 +1,425 @@
+import ws from 'k6/ws';
+import {check} from 'k6';
+import {Rate, Trend, Counter} from 'k6/metrics';
+
+const connectionLatency = new Trend('ws_connection_latency', true);
+const responseLatency = new Trend('ws_response_latency', true);
+const connectionSuccessRate = new Rate('ws_connection_success');
+const messageSuccessRate = new Rate('ws_message_success');
+const messagesSentCounter = new Counter('ws_messages_sent_total');
+const messagesReceivedCounter = new Counter('ws_messages_received_total');
+const websocketErrorCounter = new Counter('websocket_errors_total');
+
+// Configuration from environment variables
+const INWORLD_API_KEY = __ENV.INWORLD_API_KEY || '';
+const VU_ID = __VU;
+const ENV_NAME = __ENV.ENV_NAME || 'local-mock';
+const IS_DEBUG = __ENV.DEBUG === 'true';
+const USE_WORKSPACE_PER_VU = __ENV.USE_WORKSPACE_PER_VU === 'true';
+const USE_ITEM_DONE_FOR_LATENCY = __ENV.USE_ITEM_DONE_FOR_LATENCY === 'true';
+const WAIT_FOR_RESPONSE = __ENV.WAIT_FOR_RESPONSE === 'true';
+
+let baseWsUrl;
+// Select the base URL based on the environment name
+switch (ENV_NAME.toLowerCase()) {
+  case 'local-proxy':
+    // local w-proxy
+    baseWsUrl = 'ws://localhost:8081/api/v1/realtime/session';
+    break;
+  case 'local-realtime':
+    // local realtime
+    baseWsUrl = 'ws://localhost:4000/session';
+    break;
+  case 'dev':
+    // dev Realtime service
+    baseWsUrl = 'wss://api.dev.inworld.ai:443/api/v1/realtime/session';
+    break;
+  case 'local-mock':
+  default:
+    // local mock web-socket server
+    baseWsUrl = 'ws://localhost:9002/api/v1/realtime/session';
+    break;
+}
+
+const WS_URL = `${baseWsUrl}?protocol=realtime`;
+console.log(`[Config] Running test against environment: ${ENV_NAME}. URL: ${WS_URL}`);
+console.log(`[Config] USE_ITEM_DONE_FOR_LATENCY: ${USE_ITEM_DONE_FOR_LATENCY} (latency for response.create will be measured from response.done)`);
+console.log(`[Config] WAIT_FOR_RESPONSE: ${WAIT_FOR_RESPONSE} (send next message only after receiving response to previous)`);
+
+// Messages to send
+const messages = [
+  {type: 'session.update', session: {instructions: 'You are a helpful assistant that speaks in a friendly tone.'}},
+  {type: 'session.update', session: {audio: {output: {voice: 'Alex'}}}},
+  {type: 'session.update', session: {output_modalities: ["text"]}},
+  {
+    type: 'conversation.item.create',
+    item: {type: 'message', role: 'user', content: [{type: 'input_text', text: 'What is 2+2?'}]}
+  },
+  {type: 'response.create'}
+];
+
+const scenarios = {
+  small: [
+    { duration: '5s', target: 1 },
+    { duration: '5s', target: 3 },
+    { duration: '5s', target: 5 },
+    { duration: '5s', target: 5 },
+    { duration: '5s', target: 0 },
+  ],
+
+  medium: [
+    { duration: '5s', target: 5 },
+    { duration: '5s', target: 8 },
+    { duration: '5s', target: 15 },
+    { duration: '10s', target: 15 },
+    { duration: '5s', target: 0 },
+  ],
+
+  xmedium: [
+    { duration: '5s', target: 10 },
+    { duration: '5s', target: 15 },
+    { duration: '5s', target: 25 },
+    { duration: '10s', target: 25 },
+    { duration: '5s', target: 0 },
+  ],
+
+  x2medium: [
+    { duration: '5s', target: 20 },
+    { duration: '5s', target: 30 },
+    { duration: '5s', target: 50 },
+    { duration: '10s', target: 50 },
+    { duration: '5s', target: 0 },
+  ],
+
+  x2mediumLong: [
+    { duration: '10s', target: 20 },
+    { duration: '10s', target: 30 },
+    { duration: '10s', target: 50 },
+    { duration: '30s', target: 50 },
+    { duration: '10s', target: 0 },
+  ],
+
+  large: [
+    { duration: '10s', target: 20 },
+    { duration: '10s', target: 50 },
+    { duration: '10s', target: 80 },
+    { duration: '10s', target: 100 },
+    { duration: '30s', target: 100 },
+    { duration: '10s', target: 0 },
+  ],
+
+  xlarge: [
+    { duration: '10s', target: 20 },
+    { duration: '10s', target: 50 },
+    { duration: '10s', target: 80 },
+    { duration: '10s', target: 100 },
+    { duration: '10s', target: 150 },
+    { duration: '10s', target: 200 },
+    { duration: '30s', target: 200 },
+    { duration: '10s', target: 0 },
+  ],
+};
+
+const scenarioName = __ENV.SCENARIO || "small";
+
+// Dynamically create metrics for each message
+const messageLatencies = [];
+const messageSuccessRates = [];
+
+for (let i = 0; i < messages.length; i++) {
+  const messageIndex = i + 1; // 1-based index for metric names
+  messageLatencies.push(new Trend(`message${messageIndex}_latency`, true));
+  messageSuccessRates.push(new Rate(`message${messageIndex}_success`));
+}
+
+export const options = {
+  stages: scenarios[scenarioName],
+  thresholds: {
+    'ws_connection_success': ['rate>0.95'],
+    'ws_message_success': ['rate>0.95'],
+    'ws_connection_latency': ['p(95)<1000'],
+    'ws_response_latency': ['p(95)<5000'],
+  },
+  summaryTrendStats: ["min", "max", "avg", "med", "p(90)", "p(95)", "p(99)", "p(99.9)"],
+};
+
+export default function () {
+  const sessionKey = `test-session-${VU_ID}-${Date.now()}`;
+  const url = `${WS_URL}&key=${sessionKey}`;
+  const params = {
+    tags: {name: 'WebSocket Connection'},
+    headers: {},
+  };
+  if (INWORLD_API_KEY) {
+    params.headers['Authorization'] = `Basic ${INWORLD_API_KEY}`;
+  }
+
+  if (USE_WORKSPACE_PER_VU) {
+    params.headers['workspace-id'] = `workspace-${VU_ID}}`;
+    console.log(`[VU ${VU_ID}] Using workspace-id: ${params.headers['workspace-id']}`);
+  }
+
+  const connectionStart = Date.now();
+
+  const response = ws.connect(url, params, function (socket) {
+    const connectionEnd = Date.now();
+    const connectionTime = connectionEnd - connectionStart;
+    connectionLatency.add(connectionTime);
+    connectionSuccessRate.add(1);
+
+    // Track message sending and response times
+    const pendingMessages = new Map();
+    const pendingResponseCreate = new Map();
+    let receivedMessageCount = 0;
+    let sessionCreatedReceived = false;
+    let allMessagesSent = false;
+    let currentMessageIndex = 0;
+
+    const sendMessage = function (index) {
+      if (index >= messages.length) {
+        allMessagesSent = true;
+        return;
+      }
+
+      const messageStart = Date.now();
+      const isResponseCreate = messages[index].type === 'response.create';
+
+      if (USE_ITEM_DONE_FOR_LATENCY && isResponseCreate) {
+        pendingResponseCreate.set(index, {sentTime: messageStart});
+      } else {
+        pendingMessages.set(index, {sentTime: messageStart, responded: false});
+      }
+
+      messagesSentCounter.add(1);
+      socket.send(JSON.stringify(messages[index]));
+
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] Sent message ${index + 1}/${messages.length}:`, messages[index].type);
+      }
+
+      socket.setTimeout(() => {
+        if (USE_ITEM_DONE_FOR_LATENCY && isResponseCreate) {
+          if (pendingResponseCreate.has(index)) {
+            pendingResponseCreate.delete(index);
+            messageSuccessRate.add(0);
+            if (index >= 0 && index < messageSuccessRates.length) {
+              messageSuccessRates[index].add(0);
+            }
+            if (IS_DEBUG) {
+              console.log(`[VU ${VU_ID}] Timeout waiting for response.done for message ${index + 1}`);
+            }
+          }
+        } else {
+          if (pendingMessages.has(index) && !pendingMessages.get(index).responded) {
+            pendingMessages.delete(index);
+            messageSuccessRate.add(0);
+            if (index >= 0 && index < messageSuccessRates.length) {
+              messageSuccessRates[index].add(0);
+            }
+            if (IS_DEBUG) {
+              console.log(`[VU ${VU_ID}] Timeout waiting for response to message ${index + 1}`);
+            }
+          }
+        }
+      }, 10000);
+    };
+
+    socket.on('open', () => {
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] WebSocket connection opened to url ${url}`);
+      }
+
+      // Send the first message immediately
+      if (messages.length > 0) {
+        sendMessage(0);
+        currentMessageIndex = 1;
+      }
+
+      if (!WAIT_FOR_RESPONSE) {
+        // In timed mode, send messages with delays
+        for (let index = 1; index < messages.length; index++) {
+          socket.setTimeout(() => {
+            sendMessage(index);
+          }, index * 50);
+        }
+
+        socket.setTimeout(() => {
+          allMessagesSent = true;
+        }, (messages.length - 1) * 50);
+      }
+    });
+
+    socket.on('message', (data) => {
+      const ts = Date.now();
+      messagesReceivedCounter.add(1);
+
+      let msg;
+      try { msg = JSON.parse(data); }
+      catch { if (IS_DEBUG) console.log("Non-JSON message"); return; }
+
+      const type = msg.type || "unknown";
+      if (IS_DEBUG) console.log(`[VU ${VU_ID}] Received: ${type}`);
+
+      if (type === 'session.created') {
+        sessionCreatedReceived = true;
+        return;
+      }
+
+      if (USE_ITEM_DONE_FOR_LATENCY && type === "response.done") {
+        handleResponseDone(ts);
+      } else {
+        handleRegularResponse(ts);
+      }
+
+      attemptSendNextMessage();
+      tryCloseSocket();
+    });
+
+
+    function handleResponseDone(ts) {
+      if (pendingResponseCreate.size === 0) {
+        if (IS_DEBUG) console.log("response.done received without a pending response.create");
+        return;
+      }
+
+      const [index, entry] = [...pendingResponseCreate.entries()].sort(([a],[b]) => a - b)[0];
+      pendingResponseCreate.delete(index);
+
+      const latency = Math.max(0, ts - entry.sentTime);
+      recordSuccess(index, latency);
+
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] response.done matched message ${index+1}, latency: ${latency}ms`);
+      }
+    }
+
+    function handleRegularResponse(ts) {
+      if (pendingMessages.size === 0) {
+        if (IS_DEBUG) console.log("Response w/o pendingMessages");
+        return;
+      }
+
+      const [index, entry] = [...pendingMessages.entries()].sort(([a],[b]) => a - b)[0];
+      pendingMessages.delete(index);
+
+      let latency = ts - entry.sentTime;
+      if (latency < 0) latency = 0;
+      if (latency === 0) latency = 0.5;
+
+      recordSuccess(index, latency);
+
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] matched response for message ${index+1}, latency: ${latency}ms`);
+      }
+    }
+
+    function recordSuccess(index, latency) {
+      responseLatency.add(latency);
+      messageSuccessRate.add(1);
+
+      if (index >= 0 && index < messageLatencies.length) {
+        messageLatencies[index].add(latency);
+        messageSuccessRates[index].add(1);
+      }
+    }
+
+    function attemptSendNextMessage() {
+      if (!WAIT_FOR_RESPONSE) return;
+      if (currentMessageIndex >= messages.length) return;
+
+      socket.setTimeout(() => {
+        sendMessage(currentMessageIndex);
+        currentMessageIndex++;
+        if (currentMessageIndex >= messages.length) allMessagesSent = true;
+      }, 50);
+    }
+
+    function tryCloseSocket() {
+      const pendingCount =
+        pendingMessages.size +
+        (USE_ITEM_DONE_FOR_LATENCY ? pendingResponseCreate.size : 0);
+
+      if (!allMessagesSent || pendingCount > 0) return;
+
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] All responses received. Closing socket.`);
+      }
+
+      socket.close();
+    }
+
+    socket.on('error', function (e) {
+      console.error(`[VU ${VU_ID}] WebSocket error:`, e.error());
+      websocketErrorCounter.add(1);
+      connectionSuccessRate.add(0);
+      check(false, {'WebSocket connection must not have errors': e.error() == undefined});
+    });
+
+    socket.on('close', () => {
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] Connection closed`);
+      }
+
+      for (const [msgIndex, entry] of pendingMessages.entries()) {
+        if (!entry.responded) {
+          messageSuccessRate.add(0);
+          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
+            messageSuccessRates[msgIndex].add(0);
+          }
+        }
+      }
+      pendingMessages.clear();
+
+      if (USE_ITEM_DONE_FOR_LATENCY) {
+        for (const [msgIndex, entry] of pendingResponseCreate.entries()) {
+          messageSuccessRate.add(0);
+          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
+            messageSuccessRates[msgIndex].add(0);
+          }
+        }
+        pendingResponseCreate.clear();
+      }
+    });
+
+    const safetyTimeout = (messages.length * 1000) + 1000;
+
+    socket.setTimeout(() => {
+      const pendingCount = pendingMessages.size + (USE_ITEM_DONE_FOR_LATENCY ? pendingResponseCreate.size : 0);
+      if (IS_DEBUG) {
+        console.log(`[VU ${VU_ID}] Safety timeout - closing connection. Sent: ${messages.length}, Received: ${receivedMessageCount}, Pending: ${pendingCount}`);
+      }
+
+      for (const [msgIndex, entry] of pendingMessages.entries()) {
+        if (!entry.responded) {
+          messageSuccessRate.add(0);
+          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
+            messageSuccessRates[msgIndex].add(0);
+          }
+        }
+      }
+      pendingMessages.clear();
+
+      if (USE_ITEM_DONE_FOR_LATENCY) {
+        for (const [msgIndex, entry] of pendingResponseCreate.entries()) {
+          messageSuccessRate.add(0);
+          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
+            messageSuccessRates[msgIndex].add(0);
+          }
+        }
+        pendingResponseCreate.clear();
+      }
+
+      socket.close();
+    }, safetyTimeout);
+  });
+
+  check(response, {
+    'WebSocket connection established': (r) => r && r.status === 101,
+  }, {name: 'Connection Check'});
+
+  if (!response || response.status !== 101) {
+    connectionSuccessRate.add(0);
+    const connectionTime = Date.now() - connectionStart;
+    connectionLatency.add(connectionTime);
+  }
+}
diff --git a/realtime-service/load-tests/package.json b/realtime-service/load-tests/package.json
new file mode 100644
index 0000000..166852b
--- /dev/null
+++ b/realtime-service/load-tests/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "load-tests",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "test:local:mock:small": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=small -e USE_ITEM_DONE_FOR_LATENCY=false",
+    "test:local:mock:medium": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=medium -e USE_ITEM_DONE_FOR_LATENCY=false",
+    "test:local:mock:large": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=large -e USE_ITEM_DONE_FOR_LATENCY=false",
+    "test:local:mock:xlarge": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=xlarge -e USE_ITEM_DONE_FOR_LATENCY=false",
+
+    "test:local:proxy:small": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=small -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:proxy:medium": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:proxy:large": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=large -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:proxy:xlarge": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=xlarge -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+
+    "test:local:realtime:small": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=small -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:medium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:xmedium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=xmedium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:x2medium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=x2medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:x2mediumLong": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=x2mediumLong -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:large": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=large -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:local:realtime:xlarge": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=xlarge -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
+
+    "test:dev:realtime:small": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=small -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:dev:realtime:medium": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=medium -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:dev:realtime:large": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=large -e USE_ITEM_DONE_FOR_LATENCY=true",
+    "test:dev:realtime:xlarge": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=xlarge -e USE_ITEM_DONE_FOR_LATENCY=true"
+  },
+  "private": true
+}
diff --git a/realtime-service/mock/echo_ws_server.go b/realtime-service/mock/echo_ws_server.go
new file mode 100644
index 0000000..09c95e8
--- /dev/null
+++ b/realtime-service/mock/echo_ws_server.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/gorilla/websocket"
+)
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+func echoServer(w http.ResponseWriter, r *http.Request) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Println("Upgrade failed:", err)
+		return
+	}
+	defer conn.Close()
+
+	log.Println("Client connected!")
+
+	for {
+		messageType, message, err := conn.ReadMessage()
+		if err != nil {
+			log.Println("Read failed:", err)
+			break
+		}
+
+		log.Printf("Received: %s", message)
+
+		err = conn.WriteMessage(messageType, message)
+		if err != nil {
+			log.Println("Write failed:", err)
+			break
+		}
+	}
+}
+
+func main() {
+	http.HandleFunc("/session", echoServer)
+	log.Println("WebSocket Mock Server starting on :4000/ws")
+	err := http.ListenAndServe(":4000", nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}
diff --git a/realtime-service/package-lock.json b/realtime-service/package-lock.json
new file mode 100644
index 0000000..fa4ab77
--- /dev/null
+++ b/realtime-service/package-lock.json
@@ -0,0 +1,33 @@
+{
+  "name": "animations-inc-voice-agent",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "ws": "^8.18.3"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/realtime-service/package.json b/realtime-service/package.json
new file mode 100644
index 0000000..2bb8f52
--- /dev/null
+++ b/realtime-service/package.json
@@ -0,0 +1,26 @@
+{
+  "name": "realtime-service",
+  "version": "1.0.0",
+  "description": "Realtime service with unit testing support",
+  "scripts": {
+    "test": "WS_APP_PORT=4000 jest",
+    "test:api": "WS_APP_PORT=4000 jest __tests__/api",
+    "test:watch": "WS_APP_PORT=4000 jest --watch",
+    "test:coverage": "WS_APP_PORT=4000 jest --coverage",
+    "test:verbose": "WS_APP_PORT=4000 jest --verbose"
+  },
+  "dependencies": {
+    "uuid": "^11.1.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
+    "@types/uuid": "^9.0.0",
+    "@types/ws": "^8.5.10",
+    "dotenv": "^16.4.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  }
+}
diff --git a/realtime-service/src/.gitignore b/realtime-service/src/.gitignore
new file mode 100644
index 0000000..67c86a3
--- /dev/null
+++ b/realtime-service/src/.gitignore
@@ -0,0 +1,32 @@
+# TypeScript build output
+dist/
+
+# Dependencies
+node_modules/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+coverage/
+.nyc_output/
+
diff --git a/realtime-service/src/REALTIME_API.md b/realtime-service/src/REALTIME_API.md
new file mode 100644
index 0000000..2c7b371
--- /dev/null
+++ b/realtime-service/src/REALTIME_API.md
@@ -0,0 +1,313 @@
+# OpenAI Realtime API Implementation
+
+This server now supports the OpenAI Realtime API protocol for WebSocket-based real-time voice and audio interactions.
+
+## Protocol Selection
+
+The server previously supports two protocols:
+
+1. **Legacy Protocol** (default): The original custom protocol
+2. **Realtime Protocol**: OpenAI Realtime API compatible protocol
+
+The legacy protocol is no longer supported. We now support serving realtime events through OpenAI compatible API events with a few exceptions.
+
+To use the Realtime protocol, add `protocol=realtime` as a query parameter when connecting to the WebSocket:
+
+```
+ws://YOUR_API_HOST:PORT/session?protocol=realtime&key=YOUR_SESSION_KEY
+```
+
+## Connection Flow
+
+
+### 1. Connect via WebSocket
+
+Connect to the WebSocket endpoint with the Realtime protocol:
+
+```javascript
+const ws = new WebSocket('ws://YOUR_API_HOST:PORT/session?protocol=realtime&key=YOUR_SESSION_KEY');
+
+ws.onopen = () => {
+  console.log('Connected');
+  handleOpen();
+};
+
+ws.onmessage = (event) => this.handleMessage(event);
+ws.onerror = (error) => this.handleError(error);
+ws.onclose = () => this.handleClose();
+
+```
+
+### 2. Send session.update Event
+
+You should send a session.update Event when the websocket opens, just like when you are using OpenAI API.
+
+```javascript
+const sessionUpdate = {
+      type: 'session.update',
+      session: {
+        type: 'realtime',  // Required by OpenAI API
+        output_modalities: modalities,
+        instructions: instructions,
+        tools: tools,
+        tool_choice: toolChoice,
+        audio: {
+          input: {
+            turn_detection: {
+              type: 'semantic_vad',
+              eagerness: eagerness,
+              create_response: true,
+              interrupt_response: false,
+            },
+            transcription: {
+              model: 'gpt-4o-mini-transcribe',
+            },
+          },
+          output: {
+            voice: voice,  // Selected voice from dropdown
+          },
+        },
+      },
+    };
+```
+
+You will then be able to send Client Events and receive responses from the server.
+
+## Client Events
+
+### Update Session Configuration
+
+We support partial update to session such as:
+
+```javascript
+ws.send(JSON.stringify({
+  type: 'session.update',
+  session: {
+    instructions: 'You are a friendly assistant',
+    voice: 'Hades',
+    temperature: 0.7
+  }
+}));
+```
+
+### Send Audio Input
+
+The Realtime API uses PCM16 audio at 24kHz sample rate.
+
+```javascript
+// Append audio to input buffer
+ws.send(JSON.stringify({
+  type: 'input_audio_buffer.append',
+  audio: base64AudioData  // base64-encoded PCM16 audio at 24kHz
+}));
+
+// Manually commit the audio buffer (not needed with server VAD)
+ws.send(JSON.stringify({
+  type: 'input_audio_buffer.commit'
+}));
+```
+
+### Create a Text Message
+
+```javascript
+ws.send(JSON.stringify({
+  type: 'conversation.item.create',
+  item: {
+    type: 'message',
+    role: 'user',
+    content: [
+      {
+        type: 'input_text',
+        text: 'Hello, how are you?'
+      }
+    ]
+  }
+}));
+
+// Trigger a response
+ws.send(JSON.stringify({
+  type: 'response.create'
+}));
+```
+
+### Cancel a Response
+
+```javascript
+ws.send(JSON.stringify({
+  type: 'response.cancel'
+}));
+```
+
+### Delete / Retrieve a Response via Item ID
+
+```javascript
+ws.send(JSON.stringify({
+    type: 'conversation.item.delete',
+    item_id: itemId,
+}));
+```
+
+```javascript
+ws.send(JSON.stringify({
+    type: 'conversation.item.retrieve',
+    item_id: itemId,
+}));
+```
+
+The item id will be generated by the server in the corresponding event sent back (such as `response.created`).
+
+We have covered all client events available in OpenAI Websocket Protocol, except for `conversation.item.truncate`. 
+
+## Server Events
+
+The server will send various events during the conversation:
+
+### Audio Response Flow
+
+Here's a sequence of events that will be sent back upon the server receiving audio buffer commits.
+
+1. `response.created` - Response generation started
+2. `response.output_item.added` - Output item created
+3. `response.content_part.added` - Content part (audio) added
+4. `response.audio_transcript.delta` - Transcript chunks (streaming)
+5. `response.audio.delta` - Audio chunks (streaming, base64-encoded WAV)
+6. `response.audio_transcript.done` - Transcript complete
+7. `response.audio.done` - Audio complete
+8. `response.content_part.done` - Content part complete
+9. `response.output_item.done` - Output item complete
+10. `response.done` - Response complete
+
+Refer to our API Reference for contents of such events.
+
+### Voice Activity Detection (VAD) Events
+
+When server VAD is enabled (default), instead of buffer commits, the server will decide when to create the conversation item.
+
+As such, events that informs the client will be prepended to the above flow.
+
+1. `input_audio_buffer.speech_started` - Speech detected
+2. `input_audio_buffer.speech_stopped` - Speech ended
+3. `input_audio_buffer.committed` - Audio buffer committed
+4. `conversation.item.created` - User message item created
+5. Response flow (see above)
+
+## Audio Format
+
+- **Input**: PCM16, 24kHz, mono, base64-encoded
+- **Output**: WAV format, base64-encoded (contains PCM16 at 24kHz)
+
+## Example: Simple Audio Conversation
+
+```javascript
+const ws = new WebSocket('ws://localhost:4000/session?key=my-session&protocol=realtime');
+
+ws.onmessage = (event) => {
+  const msg = JSON.parse(event.data);
+
+  switch (msg.type) {
+    case 'session.created':
+      console.log('Session ready');
+      // Start sending audio
+      break;
+
+    case 'input_audio_buffer.speech_started':
+      console.log('User started speaking');
+      break;
+
+    case 'input_audio_buffer.speech_stopped':
+      console.log('User stopped speaking');
+      break;
+
+    case 'response.audio.delta':
+      // Decode and play audio
+      const audioBuffer = Buffer.from(msg.delta, 'base64');
+      playAudio(audioBuffer);
+      break;
+
+    case 'response.audio_transcript.delta':
+      console.log('Assistant:', msg.delta);
+      break;
+
+    case 'response.done':
+      console.log('Response complete');
+      break;
+
+    case 'error':
+      console.error('Error:', msg.error);
+      break;
+  }
+};
+
+// Send audio chunks
+function sendAudioChunk(pcm16Data) {
+  ws.send(JSON.stringify({
+    type: 'input_audio_buffer.append',
+    audio: pcm16Data.toString('base64')
+  }));
+}
+```
+
+## Configuration
+
+### Server VAD (Voice Activity Detection)
+
+By default, server VAD is enabled with these settings:
+
+- **threshold**: 0.5 (voice detection sensitivity)
+- **prefix_padding_ms**: 300 (audio to include before speech)
+- **silence_duration_ms**: 500 (silence duration to detect end of speech)
+- **create_response**: true (automatically create response when speech ends)
+- Alternatively, use eagerness for presets that fits different purposes. (`'low' | 'medium' | 'high'`) The higher eagerness, the more easily for the server to conclude your conversation round.
+
+You can update these settings using `session.update`:
+
+```javascript
+ws.send(JSON.stringify({
+  type: 'session.update',
+  session: {
+    turn_detection: {
+      type: 'server_vad',
+      threshold: 0.7,
+      silence_duration_ms: 800,
+      // eagerness: 'high',
+    }
+  }
+}));
+```
+
+To disable server VAD:
+
+```javascript
+ws.send(JSON.stringify({
+  type: 'session.update',
+  session: {
+    turn_detection: null
+  }
+}));
+```
+
+## Error Handling
+
+Errors are sent as `error` events:
+
+```json
+{
+  "event_id": "evt_789",
+  "type": "error",
+  "error": {
+    "type": "invalid_request_error",
+    "code": "invalid_event",
+    "message": "Input audio buffer is empty",
+    "param": null,
+    "event_id": "evt_123"
+  }
+}
+```
+
+## Differences from OpenAI's Implementation
+
+This implementation provides compatibility with the OpenAI Realtime API protocol while using different backend services:
+
+- Uses custom LLM and TTS models (configured via environment variables)
+- Audio processing handled by Inworld Runtime graphs
+- Some advanced features (like function calling) may have different behavior
diff --git a/realtime-service/src/components/app.ts b/realtime-service/src/components/app.ts
new file mode 100644
index 0000000..d22dbd0
--- /dev/null
+++ b/realtime-service/src/components/app.ts
@@ -0,0 +1,78 @@
+import logger from '../logger';
+import { Connection } from '../types/index';
+import { InworldGraphWrapper } from './graphs/graph';
+import { InworldAppConfig } from './runtime_app_manager';
+import { DEFAULT_LLM_MODEL_NAME, DEFAULT_LLM_PROVIDER, DEFAULT_VOICE_ID, DEFAULT_TTS_MODEL_ID } from '../config';
+
+export class InworldApp {
+  graphId?: string;
+  llmModelName: string;
+  llmProvider: string;
+  voiceId: string;
+  graphVisualizationEnabled: boolean;
+  ttsModelId: string;
+  assemblyAIApiKey: string;
+  useMocks: boolean;
+  connections: {
+    [sessionId: string]: Connection;
+  } = {};
+
+  graphWithAudioInput: InworldGraphWrapper;
+
+  private constructor(config: InworldAppConfig) {
+    this.graphId = config.graphId;
+    this.llmModelName = config.llmModelName || DEFAULT_LLM_MODEL_NAME;
+    this.llmProvider = config.llmProvider || DEFAULT_LLM_PROVIDER;
+    this.voiceId = config.voiceId || DEFAULT_VOICE_ID;
+    this.ttsModelId = config.ttsModelId || DEFAULT_TTS_MODEL_ID;
+    this.graphVisualizationEnabled = config.graphVisualizationEnabled!;
+    this.assemblyAIApiKey = config.assemblyAIApiKey || '';
+    this.useMocks = config.useMocks ?? false;
+
+    // Use shared connections if provided, otherwise create own
+    this.connections = config.sharedConnections || {};
+  }
+
+  /**
+   * Factory method to create and initialize an InworldApp instance
+   * Use this instead of calling the constructor directly
+   */
+  static async create(config: InworldAppConfig): Promise<InworldApp> {
+    const app = new InworldApp(config);
+    await app.initialize();
+    return app;
+  }
+
+  private async initialize() {
+    // Create audio graph with Assembly.AI STT (handles both audio and text inputs)
+    this.graphWithAudioInput = await InworldGraphWrapper.create({
+      llmModelName: this.llmModelName,
+      llmProvider: this.llmProvider,
+      voiceId: this.voiceId,
+      connections: this.connections,
+      graphVisualizationEnabled: this.graphVisualizationEnabled,
+      ttsModelId: this.ttsModelId,
+      useAssemblyAI: true,
+      assemblyAIApiKey: this.assemblyAIApiKey,
+      useMocks: this.useMocks,
+    });
+
+    logger.info('✓ Audio input graph initialized (Assembly.AI STT)');
+  }
+
+  /**
+   * Remove a session and clean up its connection
+   */
+  removeSession(sessionId: string): void {
+    delete this.connections[sessionId];
+  }
+
+  async shutdown() {
+    // Clear all connections
+    Object.keys(this.connections).forEach(sessionId => {
+      delete this.connections[sessionId];
+    });
+
+    await this.graphWithAudioInput.destroy();
+  }
+}
diff --git a/realtime-service/src/components/audio/audio_utils.ts b/realtime-service/src/components/audio/audio_utils.ts
new file mode 100644
index 0000000..c11dad3
--- /dev/null
+++ b/realtime-service/src/components/audio/audio_utils.ts
@@ -0,0 +1,91 @@
+/**
+ * Audio utility functions for converting between audio formats
+ */
+import logger from '../../logger';
+
+/**
+ * Convert Float32Array (-1.0 to 1.0) to Int16Array PCM16 (-32768 to 32767)
+ * @param float32Data - Input audio data as Float32Array
+ * @returns Int16Array containing PCM16 audio data
+ */
+export function float32ToPCM16(float32Data: Float32Array): Int16Array {
+  const pcm16 = new Int16Array(float32Data.length);
+  for (let i = 0; i < float32Data.length; i++) {
+    // Clamp values to [-1, 1] range
+    const clamped = Math.max(-1, Math.min(1, float32Data[i]));
+    // Convert to 16-bit PCM
+    pcm16[i] = clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff;
+  }
+  return pcm16;
+}
+
+/**
+ * Convert audio data to PCM16 base64 format for OpenAI Realtime API
+ * @param audioData - Audio data in various formats (array, Buffer, Float32Array, base64 string)
+ * @param sampleRate - Sample rate of the audio (for logging purposes)
+ * @param debugLabel - Label for debug logging
+ * @returns Base64 encoded PCM16 audio data, or null if conversion fails
+ */
+export function convertToPCM16Base64(
+  audioData: any,
+  sampleRate?: number,
+  debugLabel: string = 'Audio',
+): string | null {
+  if (!audioData) {
+    logger.error({ debugLabel }, 'Audio Utils - No audio data provided');
+    return null;
+  }
+
+  // Convert audio data to Float32Array based on its actual type
+  let floatSamples: Float32Array;
+
+  if (Array.isArray(audioData)) {
+    // The array contains byte values from a Buffer, not float values
+    // Interpret these bytes as Float32 data (4 bytes per float)
+    // console.log(`[${debugLabel}] Converting byte array to Float32Array`);
+    const byteBuffer = Buffer.from(audioData);
+    floatSamples = new Float32Array(
+      byteBuffer.buffer,
+      byteBuffer.byteOffset,
+      byteBuffer.length / 4,
+    );
+  } else if (Buffer.isBuffer(audioData)) {
+    // If it's already a Buffer
+    logger.debug({ debugLabel }, 'Audio Utils - Converting Buffer to Float32Array');
+    floatSamples = new Float32Array(
+      audioData.buffer,
+      audioData.byteOffset,
+      audioData.length / 4,
+    );
+  } else if (audioData instanceof Float32Array) {
+    // Already Float32Array
+    logger.debug({ debugLabel }, 'Audio Utils - Using existing Float32Array');
+    floatSamples = audioData;
+  } else if (typeof audioData === 'string') {
+    // If it's a base64 string (legacy format)
+    logger.debug({ debugLabel }, 'Audio Utils - Decoding base64 string to Float32Array');
+    const decodedData = Buffer.from(audioData, 'base64');
+    floatSamples = new Float32Array(
+      decodedData.buffer,
+      decodedData.byteOffset,
+      decodedData.length / 4,
+    );
+  } else {
+    logger.error({ debugLabel, dataType: typeof audioData }, `Audio Utils - Unsupported audio data type: ${typeof audioData}`);
+    return null;
+  }
+
+  // Validate Float32Array has data
+  if (floatSamples.length === 0) {
+    logger.warn({ debugLabel }, 'Audio Utils - Skipping zero-length audio samples');
+    return null;
+  }
+
+  // Convert Float32 (-1.0 to 1.0) to PCM16 (-32768 to 32767)
+  const pcm16 = float32ToPCM16(floatSamples);
+
+  const audioBase64 = Buffer.from(pcm16.buffer).toString('base64');
+  logger.debug({ debugLabel, length: audioBase64.length }, 'Audio Utils - Sending base64 audio');
+
+  return audioBase64;
+}
diff --git a/realtime-service/src/components/audio/multimodal_stream_manager.ts b/realtime-service/src/components/audio/multimodal_stream_manager.ts
new file mode 100644
index 0000000..8c5d5c6
--- /dev/null
+++ b/realtime-service/src/components/audio/multimodal_stream_manager.ts
@@ -0,0 +1,125 @@
+import { AudioChunkInterface } from '@inworld/runtime/common';
+import { GraphTypes } from '@inworld/runtime/graph';
+
+import logger from '../../logger';
+
+/**
+ * Manages a stream of multimodal content (audio and/or text) that can be fed
+ * asynchronously as data arrives from websocket connections.
+ *
+ * This unifies audio and text streaming into a single interface that always
+ * yields MultimodalContent, making it compatible with entry node routing.
+ */
+export class MultimodalStreamManager {
+  private queue: GraphTypes.MultimodalContent[] = [];
+  private waitingResolvers: Array<
+    (value: IteratorResult<GraphTypes.MultimodalContent>) => void
+  > = [];
+  private ended = false;
+
+  /**
+   * Add an audio chunk to the stream (wrapped in MultimodalContent)
+   */
+  pushAudio(chunk: AudioChunkInterface): void {
+    if (this.ended) {
+      return;
+    }
+
+    // Create GraphTypes.Audio object and wrap in MultimodalContent
+    const audioData = new GraphTypes.Audio({
+      data: Array.isArray(chunk.data) ? chunk.data : Array.from(chunk.data),
+      sampleRate: chunk.sampleRate,
+    });
+    const multimodalContent = new GraphTypes.MultimodalContent({
+      audio: audioData,
+    });
+
+    this.pushContent(multimodalContent);
+  }
+
+  /**
+   * Add text to the stream (wrapped in MultimodalContent)
+   */
+  pushText(text: string): void {
+    if (this.ended) {
+      return;
+    }
+
+    const multimodalContent = new GraphTypes.MultimodalContent({ text });
+    this.pushContent(multimodalContent);
+  }
+
+  /**
+   * Internal method to push MultimodalContent to the stream
+   */
+  private pushContent(content: GraphTypes.MultimodalContent): void {
+    // If there are waiting consumers, resolve immediately
+    if (this.waitingResolvers.length > 0) {
+      const resolve = this.waitingResolvers.shift()!;
+      resolve({ value: content, done: false });
+    } else {
+      // Otherwise, queue the content
+      this.queue.push(content);
+    }
+  }
+
+  /**
+   * Mark the stream as ended
+   */
+  end(): void {
+    logger.info('[MultimodalStreamManager] Ending stream');
+    this.ended = true;
+
+    // Resolve all waiting consumers with done signal
+    while (this.waitingResolvers.length > 0) {
+      const resolve = this.waitingResolvers.shift()!;
+      resolve({ value: undefined as any, done: true });
+    }
+  }
+
+  /**
+   * Create an async iterator for the stream
+   */
+  async *createStream(): AsyncIterableIterator<GraphTypes.MultimodalContent> {
+    while (true) {
+      // If stream ended and queue is empty, we're done
+      if (this.ended && this.queue.length === 0) {
+        logger.info('[MultimodalStreamManager] Stream iteration complete');
+        return;
+      }
+
+      // If we have queued content, yield it immediately
+      if (this.queue.length > 0) {
+        const content = this.queue.shift()!;
+        yield content;
+        continue;
+      }
+
+      // If stream ended but we just exhausted the queue, we're done
+      if (this.ended) {
+        logger.info('[MultimodalStreamManager] Stream iteration complete');
+        return;
+      }
+
+      // Otherwise, wait for new content
+      const result = await new Promise<
+        IteratorResult<GraphTypes.MultimodalContent>
+      >((resolve) => {
+        this.waitingResolvers.push(resolve);
+      });
+
+      if (result.done) {
+        return;
+      }
+
+      yield result.value;
+    }
+  }
+
+  /**
+   * Check if the stream has ended
+   */
+  isEnded(): boolean {
+    return this.ended;
+  }
+}
diff --git a/realtime-service/src/components/audio/realtime_audio_handler.ts b/realtime-service/src/components/audio/realtime_audio_handler.ts
new file mode 100644
index 0000000..9615b64
--- /dev/null
+++ b/realtime-service/src/components/audio/realtime_audio_handler.ts
@@ -0,0 +1,213 @@
+import logger from '../../logger';
+import { formatSession, formatError } from '../../log-helpers';
+import { INPUT_SAMPLE_RATE } from '../../config';
+import * as RT from '../../types/realtime';
+import { InworldApp } from '../app';
+import { MultimodalStreamManager } from './multimodal_stream_manager';
+import { RealtimeEventFactory } from '../realtime/realtime_event_factory';
+import { RealtimeGraphExecutor } from '../graphs/realtime_graph_executor';
+import { RealtimeSessionManager } from '../realtime/realtime_session_manager';
+
+export class RealtimeAudioHandler {
+  constructor(
+    private inworldApp: InworldApp,
+    private sessionKey: string,
+    private send: (data: RT.ServerEvent) => void,
+    private graphExecutor: RealtimeGraphExecutor,
+    private sessionManager: RealtimeSessionManager
+  ) {}
+
+  /**
+   * Ensures that the audio graph execution is running.
+   * Creates the multimodal stream manager and starts the graph execution if not already running.
+   * @param connection - The connection object to initialize
+   * @param context - Context string for logging (e.g., 'Audio', 'Text Input')
+   */
+  private ensureAudioGraphExecution(
+    connection: NonNullable<typeof this.inworldApp.connections[string]>,
+    context: string = 'Audio'
+  ): void {
+    if (connection.multimodalStreamManager) {
+      return;
+    }
+
+    connection.multimodalStreamManager = new MultimodalStreamManager();
+
+    const session = this.sessionManager.getSession();
+
+    // Start the audio graph execution with the stream
+    const audioStreamInput = {
+      sessionId: this.sessionKey,
+      state: connection.state,
+      voiceId: connection.state.voiceId || session.session.audio.output.voice,
+    };
+
+    // Use the Assembly.AI audio graph
+    const graphWrapper = this.inworldApp.graphWithAudioInput;
+
+    // Start graph execution in the background - it will consume from the stream
+    connection.currentAudioGraphExecution =
+      this.graphExecutor.executeAudioGraph({
+        sessionId: this.sessionKey,
+        workspaceId: connection.workspaceId,
+        apiKey: connection.apiKey,
+        input: audioStreamInput,
+        graphWrapper,
+        multimodalStreamManager: connection.multimodalStreamManager,
+      }).catch((error) => {
+        logger.error({ err: error, sessionId: this.sessionKey }, `${context} - Error in audio graph execution`);
+        // Clean up on error
+        if (connection.multimodalStreamManager) {
+          connection.multimodalStreamManager.end();
+          connection.multimodalStreamManager = undefined;
+        }
+        connection.currentAudioGraphExecution = undefined;
+        // Send error to websocket
+        this.send(
+          RealtimeEventFactory.error({
+            type: 'server_error',
+            message: error instanceof Error ? error.message : 'Error in audio graph execution',
+          }),
+        );
+      });
+  }
+
+  /**
+   * Handle input_audio_buffer.append event
+   * Stream audio directly to Inworld SDK 0.8 audio graph
+   */
+  async handleInputAudioBufferAppend(
+    event: RT.InputAudioBufferAppendEvent,
+  ): Promise<void> {
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (!connection) {
+      logger.error({ sessionId: this.sessionKey }, 'Audio - No connection found');
+      return;
+    }
+
+    // Decode base64 audio (PCM16 at 24kHz from OpenAI)
+    const audioBuffer = Buffer.from(event.audio, 'base64');
+    const int16Array = new Int16Array(
+      audioBuffer.buffer,
+      audioBuffer.byteOffset,
+      audioBuffer.length / 2,
+    );
+
+    // Convert PCM16 Int16 to Float32 for Inworld graph (normalize to -1.0 to 1.0)
+    const float32Array = new Float32Array(int16Array.length);
+    for (let i = 0; i < int16Array.length; i++) {
+      float32Array[i] = int16Array[i] / 32768.0;
+    }
+
+    // Downsample from 24kHz to 16kHz (2:3 ratio)
+    // For every 3 samples at 24kHz, we output 2 samples at 16kHz
+    const targetLength = Math.floor(float32Array.length * 2 / 3);
+    const resampled = new Float32Array(targetLength);
+    
+    for (let i = 0; i < targetLength; i++) {
+      const sourceIndex = i * 1.5; // 24kHz/16kHz = 1.5
+      const index0 = Math.floor(sourceIndex);
+      const index1 = Math.min(index0 + 1, float32Array.length - 1);
+      const frac = sourceIndex - index0;
+      
+      // Linear interpolation
+      resampled[i] = float32Array[index0] * (1 - frac) + float32Array[index1] * frac;
+    }
+
+    // Convert to number array for MultimodalStreamManager
+    const audioData = Array.from(resampled);
+
+    // Ensure the audio graph execution is running
+    this.ensureAudioGraphExecution(connection, 'Audio');
+
+    // Push the audio chunk to the stream (already resampled to 16kHz)
+    connection.multimodalStreamManager!.pushAudio({
+      data: audioData,
+      sampleRate: INPUT_SAMPLE_RATE, // 16kHz for Inworld graph
+    });
+  }
+
+  /**
+   * Handle input_audio_buffer.commit event
+   * End the audio stream and wait for graph to complete
+   */
+  async handleInputAudioBufferCommit(
+    event: RT.InputAudioBufferCommitEvent,
+  ): Promise<void> {
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (!connection) {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          message: 'No connection found',
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    if (!connection.multimodalStreamManager) {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          message: 'No active audio stream',
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    logger.info({ sessionId: this.sessionKey }, `Commit - Manual commit requested - ending audio stream [${this.sessionKey}]`);
+    connection.multimodalStreamManager.end();
+
+    // Wait for the graph execution to complete
+    if (connection.currentAudioGraphExecution) {
+      await connection.currentAudioGraphExecution;
+    }
+
+    // Clear the buffer
+    this.sessionManager.getSession().inputAudioBuffer = [];
+  }
+
+  /**
+   * Handle input_audio_buffer.clear event
+   */
+  async handleInputAudioBufferClear(
+    event: RT.InputAudioBufferClearEvent,
+  ): Promise<void> {
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (connection?.multimodalStreamManager) {
+      connection.multimodalStreamManager.end();
+      connection.multimodalStreamManager = undefined;
+      connection.currentAudioGraphExecution = undefined;
+    }
+
+    this.sessionManager.getSession().inputAudioBuffer = [];
+    this.send(RealtimeEventFactory.inputAudioBufferCleared());
+  }
+
+  /**
+   * Handle text input by pushing it to the multimodal stream manager
+   * This unifies text and audio inputs through the same audio graph
+   */
+  async handleTextInput(text: string): Promise<void> {
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (!connection) {
+      logger.error({ sessionId: this.sessionKey }, 'Text Input - No connection found');
+      return;
+    }
+
+    logger.info({ sessionId: this.sessionKey, text: text.substring(0, 100) }, `Text Input - Pushing text to audio graph: "${text.substring(0, 50)}..."`);
+
+    // Ensure the audio graph execution is running
+    this.ensureAudioGraphExecution(connection, 'Text Input');
+
+    // Push the text to the stream
+    connection.multimodalStreamManager!.pushText(text);
+
+    // Don't wait for completion here - let the graph run in the background
+    // The graph will automatically create a response when it processes the text
+    // The response.create event will wait for completion if needed
+  }
+}
+
diff --git a/realtime-service/src/components/graphs/graph.ts b/realtime-service/src/components/graphs/graph.ts
new file mode 100644
index 0000000..704fdb9
--- /dev/null
+++ b/realtime-service/src/components/graphs/graph.ts
@@ -0,0 +1,308 @@
+import {
+  Graph,
+  GraphBuilder,
+  ProxyNode,
+  RemoteLLMChatNode,
+  RemoteTTSNode,
+  FakeTTSComponent,
+  TextAggregatorNode,
+  TextChunkingNode, FakeRemoteLLMComponent,
+  RemoteLLMChatRoutingNode  // TODO: Create GraphTypes.LLMChatRoutingRequest and use remoteLLMChatRoutingNode instead
+} from '@inworld/runtime/graph';
+import * as os from 'os';
+import * as path from 'path';
+import logger from '../../logger';
+
+import {
+  INPUT_SAMPLE_RATE,
+  TTS_SAMPLE_RATE,
+} from '../../config';
+import { CreateGraphPropsInterface, State, TextInput } from '../../types/index';
+import { getAssemblyAISettingsForEagerness } from '../../types/settings';
+import { AssemblyAISTTWebSocketNode } from './nodes/assembly_ai_stt_ws_node';
+import { DialogPromptBuilderNode } from './nodes/dialog_prompt_builder_node';
+import { InteractionQueueNode } from './nodes/interaction_queue_node';
+import { StateUpdateNode } from './nodes/state_update_node';
+import { TextInputNode } from './nodes/text_input_node';
+import { TranscriptExtractorNode } from './nodes/transcript_extractor_node';
+import { TTSRequestBuilderNode } from './nodes/tts_request_builder_node';
+
+export class InworldGraphWrapper {
+  graph: Graph;
+  assemblyAINode: AssemblyAISTTWebSocketNode;
+
+  private constructor({ graph, assemblyAINode }: { graph: Graph; assemblyAINode: AssemblyAISTTWebSocketNode }) {
+    this.graph = graph;
+    this.assemblyAINode = assemblyAINode;
+  }
+
+  async destroy() {
+    await this.graph.stop();
+  }
+
+  static async create(props: CreateGraphPropsInterface) {
+    const {
+      llmModelName,
+      llmProvider,
+      voiceId,
+      connections,
+      ttsModelId,
+      useMocks = false,
+    } = props;
+
+    const postfix = `-multimodal`;
+
+    const dialogPromptBuilderNode = new DialogPromptBuilderNode({
+      id: `dialog-prompt-builder-node${postfix}`,
+    });
+
+    const textInputNode = new TextInputNode({
+      id: `text-input-node${postfix}`,
+      connections,
+      reportToClient: true,
+    });
+
+    const llmNode = new RemoteLLMChatNode({
+      id: `llm-node${postfix}`,
+      provider: llmProvider,
+      modelName: llmModelName,
+      stream: true,
+      textGenerationConfig: {
+        maxNewTokens: 320
+      },
+      reportToClient: true,
+      ...(useMocks && {
+        llmComponent: new FakeRemoteLLMComponent({
+          id: `llm-component${postfix}`,
+          modelName: llmModelName,
+          provider: llmProvider,
+        }),
+      }),
+    });
+
+    const textChunkingNode = new TextChunkingNode({
+      id: `text-chunking-node${postfix}`,
+    });
+
+    const textAggregatorNode = new TextAggregatorNode({
+      id: `text-aggregator-node${postfix}`,
+    });
+
+    const stateUpdateNode = new StateUpdateNode({
+      id: `state-update-node${postfix}`,
+      connections,
+      reportToClient: true,
+    });
+
+    const ttsRequestBuilderNode = new TTSRequestBuilderNode({
+      id: `tts-request-builder-node${postfix}`,
+      connections,
+      defaultVoiceId: voiceId,
+      reportToClient: false,
+    });
+
+    const ttsNode = new RemoteTTSNode({
+      id: `tts-node${postfix}`,
+      speakerId: voiceId,
+      modelId: ttsModelId,
+      sampleRate: TTS_SAMPLE_RATE,
+      temperature: 1.1,
+      speakingRate: 1,
+      reportToClient: true,
+      ...(useMocks && {
+        ttsComponent: new FakeTTSComponent({
+          id: `tts-component-${postfix}`,
+          loadTestConfig: {
+            firstChunkDelay: 200,
+            sampleRate: 48000,
+            errorProbability: 0.0,
+            chunksPerRequest: 20,
+            interChunkDelay: 100,
+            collectMetrics: true,
+          },
+        }),
+      }),
+    });
+
+    // A second branch that only executes text chunking - we will not execute TTS when output_modality doesn't contain audio
+    const dialogPromptBuilderNodeTextOnly = new DialogPromptBuilderNode({
+      id: `dialog-prompt-builder-node-text-only${postfix}`,
+    });
+
+    const textChunkingNodeTextOnly = new TextChunkingNode({
+      id: `text-chunking-node-text-only${postfix}`,
+      reportToClient: true,
+    });
+
+    const llmNodeTextOnly = new RemoteLLMChatNode({
+      id: `llm-node-text-only${postfix}`,
+      provider: llmProvider,
+      modelName: llmModelName,
+      stream: true,
+      textGenerationConfig: { maxNewTokens: 320 },
+      reportToClient: true,
+      ...(useMocks && {
+        llmComponent: new FakeRemoteLLMComponent({
+          id: `llm-component-text-only${postfix}`,
+          modelName: llmModelName,
+          provider: llmProvider,
+        }),
+      }),
+    });
+
+    const textAggregatorNodeTextOnly = new TextAggregatorNode({
+      id: `text-aggregator-node-text-only${postfix}`,
+    });
+
+    const stateUpdateNodeTextOnly = new StateUpdateNode({
+      id: `state-update-node-text-only${postfix}`,
+      connections,
+      reportToClient: true,
+    });
+    // End of the text only branch
+
+    const graphName = `voice-agent${postfix}`;
+    const graphBuilder = new GraphBuilder({
+      id: graphName,
+      enableRemoteConfig: false,
+    });
+
+    graphBuilder
+      .addNode(textInputNode)
+      .addNode(dialogPromptBuilderNode)
+      .addNode(llmNode)
+      .addNode(textChunkingNode)
+      .addNode(textAggregatorNode)
+      .addNode(ttsRequestBuilderNode)
+      .addNode(ttsNode)
+      .addNode(stateUpdateNode)
+      .addEdge(textInputNode, dialogPromptBuilderNode, {
+        condition: async (input: State) => {
+          return input?.output_modalities.includes("audio")
+        },
+      })
+      .addEdge(dialogPromptBuilderNode, llmNode)
+      .addEdge(llmNode, textChunkingNode)
+      .addEdge(textInputNode, ttsRequestBuilderNode, {
+        condition: async (input: State) => {
+          return input?.output_modalities.includes("audio")
+        },
+      })
+      .addEdge(textChunkingNode, ttsRequestBuilderNode)
+      .addEdge(ttsRequestBuilderNode, ttsNode)
+      .addEdge(llmNode, textAggregatorNode)
+      .addEdge(textAggregatorNode, stateUpdateNode)
+      // Text-only outputs nodes/edges
+      .addNode(dialogPromptBuilderNodeTextOnly)
+      .addNode(textChunkingNodeTextOnly)
+      .addNode(llmNodeTextOnly)
+      .addNode(textAggregatorNodeTextOnly)
+      .addNode(stateUpdateNodeTextOnly)
+      .addEdge(textInputNode, dialogPromptBuilderNodeTextOnly, {
+        condition: async (input: State) => {
+          return !input?.output_modalities.includes("audio") && input?.output_modalities.includes("text")
+        },
+      })
+      .addEdge(dialogPromptBuilderNodeTextOnly, llmNodeTextOnly)
+      .addEdge(llmNodeTextOnly, textChunkingNodeTextOnly)
+      .addEdge(llmNodeTextOnly, textAggregatorNodeTextOnly)
+      .addEdge(textAggregatorNodeTextOnly, stateUpdateNodeTextOnly)
+      ;
+
+
+    // Validate configuration
+    if (!props.assemblyAIApiKey) {
+      throw new Error('Assembly.AI API key is required for audio input');
+    }
+
+    logger.info('Building graph with Multimodal pipeline');
+
+    // Start node to pass the audio input to Assembly.AI STT
+    const audioInputNode = new ProxyNode();
+    const interactionQueueNode = new InteractionQueueNode({
+      id: `interaction-queue-node${postfix}`,
+      connections,
+      reportToClient: false,
+    });
+
+    // Get eagerness settings from connection state, default to 'medium'
+    const connection = connections[Object.keys(connections)[0]];
+    const eagerness = connection?.state?.eagerness || 'medium';
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness(eagerness);
+
+    logger.info({
+      eagerness,
+      profile: turnDetectionSettings.description,
+      endOfTurnConfidenceThreshold: turnDetectionSettings.endOfTurnConfidenceThreshold,
+      minEndOfTurnSilenceWhenConfident: turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
+      maxTurnSilence: turnDetectionSettings.maxTurnSilence,
+    }, `Configured eagerness: ${eagerness} (${turnDetectionSettings.description})`);
+
+    const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
+      id: `assembly-ai-stt-ws-node${postfix}`,
+      config: {
+        apiKey: props.assemblyAIApiKey!,
+        connections: connections,
+        sampleRate: INPUT_SAMPLE_RATE,
+        formatTurns: false,
+        endOfTurnConfidenceThreshold: turnDetectionSettings.endOfTurnConfidenceThreshold,
+        minEndOfTurnSilenceWhenConfident: turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
+        maxTurnSilence: turnDetectionSettings.maxTurnSilence,
+      },
+    });
+
+    const transcriptExtractorNode = new TranscriptExtractorNode({
+      id: `transcript-extractor-node${postfix}`,
+      reportToClient: true,
+    });
+
+    graphBuilder
+      .addNode(audioInputNode)
+      .addNode(assemblyAISTTNode)
+      .addNode(transcriptExtractorNode)
+      .addNode(interactionQueueNode)
+      .addEdge(audioInputNode, assemblyAISTTNode)
+      .addEdge(assemblyAISTTNode, assemblyAISTTNode, {
+        condition: async (input: any) => {
+          return input?.stream_exhausted !== true;
+        },
+        loop: true,
+        optional: true,
+      })
+      // When interaction is complete, send to transcriptExtractorNode for processing
+      .addEdge(assemblyAISTTNode, transcriptExtractorNode, {
+        condition: async (input: any) => {
+          return input?.interaction_complete === true;
+        },
+      })
+      .addEdge(transcriptExtractorNode, interactionQueueNode)
+      .addEdge(interactionQueueNode, textInputNode, {
+        condition: (input: TextInput) => {
+          logger.debug({ text: input.text?.substring(0, 100) }, `InteractionQueueNode checking condition: "${input.text?.substring(0, 50)}..."`);
+          return input.text && input.text.trim().length > 0;
+        },
+      })
+      .addEdge(stateUpdateNode, interactionQueueNode, {
+        loop: true,
+        optional: true,
+      })
+      .setStartNode(audioInputNode);
+
+    graphBuilder.setEndNode(ttsNode);
+
+    const graph = graphBuilder.build();
+    if (props.graphVisualizationEnabled) {
+      const graphPath = path.join(os.tmpdir(), `${graphName}.png`);
+      logger.info(
+        { graphPath },
+        'The Graph visualization will be saved to this path. If you see any fatal error after this message, pls disable graph visualization'
+      );
+    }
+
+    // Return wrapper with assemblyAI node reference
+    return new InworldGraphWrapper({
+      graph,
+      assemblyAINode: assemblyAISTTNode,
+    });
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts b/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
new file mode 100644
index 0000000..8b6a9c8
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -0,0 +1,855 @@
+import { DataStreamWithMetadata } from '@inworld/runtime';
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import WebSocket from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+
+import { Connection } from '../../../types/index';
+import { getAssemblyAISettingsForEagerness } from '../../../types/settings';
+import logger from '../../../logger';
+import { formatSession, formatContext, formatError } from '../../../log-helpers';
+import { float32ToPCM16 } from '../../audio/audio_utils';
+
+/**
+ * Configuration interface for AssemblyAISTTWebSocketNode
+ */
+export interface AssemblyAISTTWebSocketNodeConfig {
+  /** Assembly.AI API key */
+  apiKey: string;
+  /** Connections map to access session state */
+  connections: { [sessionId: string]: Connection };
+  /** Sample rate of the audio stream in Hz */
+  sampleRate?: number;
+  /** Enable turn formatting from Assembly.AI */
+  formatTurns?: boolean;
+  /** End of turn confidence threshold (0-1) */
+  endOfTurnConfidenceThreshold?: number;
+  /** Minimum silence duration when confident (in milliseconds) */
+  minEndOfTurnSilenceWhenConfident?: number;
+  /** Maximum turn silence (in milliseconds) */
+  maxTurnSilence?: number;
+  /** Language code (e.g., 'en', 'es') */
+  language?: string;
+  /** Keywords/keyterms to boost recognition */
+  keytermsPrompt?: string[];
+}
+
+/**
+ * Manages a persistent WebSocket connection to Assembly.AI for a single session.
+ * Encapsulates connection lifecycle, inactivity timeouts, and message sending.
+ */
+class AssemblyAISession {
+  private ws: WebSocket | null = null;
+  private wsReady: boolean = false;
+  private wsConnectionPromise: Promise<void> | null = null;
+
+  public assemblySessionId: string = '';
+  public sessionExpiresAt: number = 0;
+  public shouldStopProcessing: boolean = false;
+
+  private inactivityTimeout: NodeJS.Timeout | null = null;
+  private lastActivityTime: number = Date.now();
+  private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
+
+  constructor(
+    public readonly sessionId: string,
+    private apiKey: string,
+    private url: string,
+    private onCleanup: (sessionId: string) => void
+  ) {}
+
+  /**
+   * Ensure WebSocket connection is ready, reconnecting if needed
+   */
+  public async ensureConnection(): Promise<void> {
+    // Check if connection is expired
+    const now = Math.floor(Date.now() / 1000);
+    const isExpired = this.sessionExpiresAt > 0 && now >= this.sessionExpiresAt;
+
+    if (
+      !this.ws ||
+      !this.wsReady ||
+      this.ws.readyState !== WebSocket.OPEN ||
+      isExpired
+    ) {
+      if (isExpired) {
+        logger.info({ sessionId: this.sessionId }, 'AssemblyAI session expired, reconnecting');
+      } else if (this.ws) {
+        logger.info({ sessionId: this.sessionId, readyState: this.ws.readyState }, `AssemblyAI connection not ready [state:${this.ws.readyState}], reconnecting`);
+      } else {
+        logger.info({ sessionId: this.sessionId }, 'AssemblyAI connecting');
+      }
+
+      // Close existing connection if any
+      this.closeWebSocket();
+
+      // Start new connection
+      this.initializeWebSocket();
+    }
+
+    if (this.wsConnectionPromise) {
+      await this.wsConnectionPromise;
+    }
+
+    // Reset flags
+    this.shouldStopProcessing = false;
+    this.resetInactivityTimer();
+  }
+
+  /**
+   * Initialize the WebSocket connection
+   */
+  private initializeWebSocket(): void {
+    logger.info({ sessionId: this.sessionId }, 'AssemblyAI initializing WebSocket');
+
+    this.wsConnectionPromise = new Promise<void>((resolve, reject) => {
+      logger.info({ sessionId: this.sessionId, url: this.url }, 'AssemblyAI WS STT - Connecting');
+
+      this.ws = new WebSocket(this.url, {
+        headers: { Authorization: this.apiKey },
+      });
+
+      this.ws.on('open', () => {
+        logger.info({ sessionId: this.sessionId }, `AssemblyAI WebSocket opened ${formatSession(this.sessionId)}`);
+        this.wsReady = true;
+        resolve();
+      });
+
+      // Permanent message handler for session metadata
+      this.ws.on('message', (data: WebSocket.Data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          if (message.type === 'Begin') {
+            this.assemblySessionId = message.id || message.session_id || '';
+            this.sessionExpiresAt = message.expires_at || 0;
+            logger.info({
+              sessionId: this.sessionId,
+              assemblySessionId: this.assemblySessionId,
+              expiresAt: this.sessionExpiresAt ? new Date(this.sessionExpiresAt * 1000).toISOString() : 'unknown',
+            }, `AssemblyAI session began ${formatSession(this.sessionId)} [assembly:${this.assemblySessionId}]`);
+          }
+        } catch (error) {
+          // Ignore parsing errors here, they might be handled by other listeners
+        }
+      });
+
+      this.ws.on('error', (error: Error) => {
+        logger.error({ err: error, sessionId: this.sessionId }, 'AssemblyAI WebSocket error');
+        this.wsReady = false;
+        reject(error);
+      });
+
+      this.ws.on('close', (code: number, reason: Buffer) => {
+        logger.info({
+          sessionId: this.sessionId,
+          code,
+          reason: reason.toString(),
+        }, `AssemblyAI WebSocket closed ${formatSession(this.sessionId)} [code:${code}] [reason:${reason.toString()}]`);
+        this.wsReady = false;
+      });
+    });
+  }
+
+  /**
+   * Add a message listener
+   */
+  public onMessage(listener: (data: WebSocket.Data) => void): void {
+    if (this.ws) {
+      this.ws.on('message', listener);
+    }
+  }
+
+  /**
+   * Remove a message listener
+   */
+  public offMessage(listener: (data: WebSocket.Data) => void): void {
+    if (this.ws) {
+      this.ws.off('message', listener);
+    }
+  }
+
+  /**
+   * Send audio data
+   */
+  public sendAudio(pcm16Data: Int16Array): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(Buffer.from(pcm16Data.buffer));
+      this.resetInactivityTimer();
+    } else {
+      logger.warn({ sessionId: this.sessionId }, 'AssemblyAI WebSocket not open, skipping audio chunk');
+    }
+  }
+
+  /**
+   * Update turn detection configuration on the active WebSocket connection
+   */
+  public updateConfiguration(config: {
+    endOfTurnConfidenceThreshold?: number;
+    minEndOfTurnSilenceWhenConfident?: number;
+    maxTurnSilence?: number;
+  }): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      const updateMessage: any = {
+        type: 'UpdateConfiguration',
+      };
+
+      if (config.endOfTurnConfidenceThreshold !== undefined) {
+        updateMessage.end_of_turn_confidence_threshold = config.endOfTurnConfidenceThreshold;
+      }
+      if (config.minEndOfTurnSilenceWhenConfident !== undefined) {
+        updateMessage.min_end_of_turn_silence_when_confident = config.minEndOfTurnSilenceWhenConfident;
+      }
+      if (config.maxTurnSilence !== undefined) {
+        updateMessage.max_turn_silence = config.maxTurnSilence;
+      }
+
+      this.ws.send(JSON.stringify(updateMessage));
+      logger.info({ sessionId: this.sessionId, config: updateMessage }, `AssemblyAI configuration updated ${formatSession(this.sessionId)}`);
+    } else {
+      logger.warn({ sessionId: this.sessionId }, 'AssemblyAI cannot update config: WebSocket not open');
+    }
+  }
+
+
+  /**
+   * Reset the inactivity timer
+   */
+  private resetInactivityTimer(): void {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+    }
+
+    this.lastActivityTime = Date.now();
+    this.inactivityTimeout = setTimeout(() => {
+      this.closeDueToInactivity();
+    }, this.INACTIVITY_TIMEOUT_MS);
+  }
+
+  /**
+   * Close connection due to inactivity
+   */
+  private closeDueToInactivity(): void {
+    const inactiveFor = Date.now() - this.lastActivityTime;
+    logger.info({ sessionId: this.sessionId, inactiveFor }, `AssemblyAI closing due to inactivity ${formatSession(this.sessionId)} [inactive:${inactiveFor}ms]`);
+
+    this.shouldStopProcessing = true;
+    this.close();
+    this.onCleanup(this.sessionId);
+  }
+
+  /**
+   * Close the WebSocket connection
+   */
+  private closeWebSocket(): void {
+    if (this.ws) {
+      try {
+        // Remove all listeners to prevent leaks
+        this.ws.removeAllListeners();
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close();
+        }
+      } catch (e) {
+        logger.warn({ err: e, sessionId: this.sessionId }, 'AssemblyAI error closing socket');
+      }
+      this.ws = null;
+      this.wsReady = false;
+    }
+  }
+
+  /**
+   * Gracefully close the session
+   */
+  public async close(): Promise<void> {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+    }
+
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify({ type: 'Terminate' }));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } catch (e) {
+        // Ignore error on send
+      }
+    }
+
+    this.closeWebSocket();
+  }
+}
+
+/**
+ * AssemblyAISTTWebSocketNode processes continuous multimodal streams (audio and/or text) using Assembly.AI's
+ * streaming Speech-to-Text service via direct WebSocket connection.
+ *
+ * This node:
+ * - Receives MultimodalContent stream (audio and/or text)
+ * - For audio: extracts audio from MultimodalContent and feeds to Assembly.AI streaming transcriber
+ * - For text: skips processing (text input should bypass STT)
+ * - Connects directly to Assembly.AI WebSocket endpoint
+ * - Detects turn endings automatically using Assembly.AI's turn detection
+ * - Returns DataStreamWithMetadata with transcribed text when a turn completes
+ */
+export class AssemblyAISTTWebSocketNode extends CustomNode {
+  private apiKey: string;
+  private connections: { [sessionId: string]: Connection };
+  private sampleRate: number;
+  private formatTurns: boolean;
+  private endOfTurnConfidenceThreshold: number;
+  private minEndOfTurnSilenceWhenConfident: number;
+  private maxTurnSilence: number;
+  private language: string;
+  private keytermsPrompt: string[];
+  private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
+
+  private sessions: Map<string, AssemblyAISession> = new Map();
+  private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
+  private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
+
+  constructor(props: {
+    id?: string;
+    config: AssemblyAISTTWebSocketNodeConfig;
+  }) {
+    const { config, ...nodeProps } = props;
+
+    if (!config.apiKey) {
+      throw new Error('AssemblyAISTTWebSocketNode requires an API key.');
+    }
+
+    if (!config.connections) {
+      throw new Error(
+        'AssemblyAISTTWebSocketNode requires a connections object.',
+      );
+    }
+
+    super({
+      id: nodeProps.id || 'assembly-ai-stt-ws-node',
+      executionConfig: {
+        sampleRate: config.sampleRate || 16000,
+        formatTurns: config.formatTurns !== false,
+        endOfTurnConfidenceThreshold:
+          config.endOfTurnConfidenceThreshold || 0.4,
+        minEndOfTurnSilenceWhenConfident:
+          config.minEndOfTurnSilenceWhenConfident || 400,
+        maxTurnSilence: config.maxTurnSilence || 1280,
+        language: config.language || 'en',
+      },
+    });
+
+    this.apiKey = config.apiKey;
+    this.connections = config.connections;
+    this.sampleRate = config.sampleRate || 16000;
+    this.formatTurns = config.formatTurns !== false;
+    this.endOfTurnConfidenceThreshold =
+      config.endOfTurnConfidenceThreshold || 0.4;
+    this.minEndOfTurnSilenceWhenConfident =
+      config.minEndOfTurnSilenceWhenConfident || 400;
+    this.maxTurnSilence = config.maxTurnSilence || 1280;
+    this.language = config.language || 'en';
+    this.keytermsPrompt = config.keytermsPrompt || [];
+
+    // Log the turn detection settings being used
+    logger.info({
+      endOfTurnConfidenceThreshold: this.endOfTurnConfidenceThreshold,
+      minEndOfTurnSilenceWhenConfident: this.minEndOfTurnSilenceWhenConfident,
+      maxTurnSilence: this.maxTurnSilence,
+      sampleRate: this.sampleRate,
+      formatTurns: this.formatTurns,
+      language: this.language,
+    }, `AssemblyAI configured [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.language}]`);
+  }
+
+  /**
+   * Build WebSocket URL with query parameters
+   * Dynamically uses connection.state.eagerness if available
+   */
+  private buildWebSocketUrl(sessionId?: string): string {
+    // Get current settings - check connection state for eagerness updates
+    let endOfTurnThreshold = this.endOfTurnConfidenceThreshold;
+    let minSilenceWhenConfident = this.minEndOfTurnSilenceWhenConfident;
+    let maxSilence = this.maxTurnSilence;
+
+    if (sessionId) {
+      const connection = this.connections[sessionId];
+      const eagerness = connection?.state?.eagerness;
+
+      if (eagerness) {
+        // Map eagerness to settings dynamically using shared settings function
+        const settings = getAssemblyAISettingsForEagerness(eagerness);
+        endOfTurnThreshold = settings.endOfTurnConfidenceThreshold;
+        minSilenceWhenConfident = settings.minEndOfTurnSilenceWhenConfident;
+        maxSilence = settings.maxTurnSilence;
+
+        logger.info({ sessionId, eagerness }, `AssemblyAI using eagerness settings: ${eagerness}`);
+      }
+    }
+
+    const params = new URLSearchParams({
+      sample_rate: this.sampleRate.toString(),
+      format_turns: this.formatTurns.toString(),
+      end_of_turn_confidence_threshold: endOfTurnThreshold.toString(),
+      min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
+      max_turn_silence: maxSilence.toString(),
+      language: this.language,
+    });
+
+    // Add keyterms if provided
+    if (this.keytermsPrompt.length > 0) {
+      this.keytermsPrompt.forEach((term) => {
+        params.append('keyterms_prompt', term);
+      });
+    }
+
+    const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
+
+    logger.info({
+      sessionId,
+      endOfTurnConfidenceThreshold: endOfTurnThreshold,
+      minEndOfTurnSilenceWhenConfident: minSilenceWhenConfident,
+      maxTurnSilence: maxSilence,
+    }, `AssemblyAI connecting ${formatSession(sessionId)} [threshold:${endOfTurnThreshold}] [silence:${minSilenceWhenConfident}ms]`);
+
+    return url;
+  }
+
+
+  /**
+   * Process multimodal stream (audio and/or text) and transcribe using Assembly.AI WebSocket
+   * For audio: extracts audio from MultimodalContent and sends to Assembly.AI
+   * For text: currently not handled (text input should bypass STT)
+   */
+  async process(
+    context: ProcessContext,
+    input0: AsyncIterableIterator<GraphTypes.MultimodalContent>,
+    input: DataStreamWithMetadata,
+  ): Promise<DataStreamWithMetadata> {
+    // Extract MultimodalContent stream from either input type
+    const multimodalStream =
+      input !== undefined &&
+      input !== null &&
+      input instanceof DataStreamWithMetadata
+        ? (input.toStream() as any as AsyncIterableIterator<GraphTypes.MultimodalContent>)
+        : input0;
+
+    const sessionId = context.getDatastore().get('sessionId') as string;
+    const connection = this.connections[sessionId];
+
+    // Check connection exists before accessing its properties
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId: ${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId: ${sessionId}`);
+    }
+
+    // Get iteration number from metadata, or parse from interactionId
+    const metadata = input?.getMetadata?.() || {};
+    let previousIteration = (metadata.iteration as number) || 0;
+
+    // If interactionId is empty, assign a UUID
+    if (!connection.state.interactionId || connection.state.interactionId === '') {
+      connection.state.interactionId = uuidv4();
+      logger.info({ sessionId, interactionId: connection.state.interactionId }, 'AssemblyAI assigned new UUID for empty interactionId');
+    }
+
+    const currentId = connection.state.interactionId;
+    const delimiterIndex = currentId.indexOf('#');
+
+    if (previousIteration === 0 && delimiterIndex !== -1) {
+      const iterationStr = currentId.substring(delimiterIndex + 1);
+      const parsedIteration = parseInt(iterationStr, 10);
+      if (!isNaN(parsedIteration) && /^\d+$/.test(iterationStr)) {
+        previousIteration = parsedIteration;
+      }
+    }
+
+    const iteration = previousIteration + 1;
+    const baseId =
+      delimiterIndex !== -1
+        ? currentId.substring(0, delimiterIndex)
+        : currentId;
+    const nextInteractionId = `${baseId}#${iteration}`;
+
+    logger.info({ sessionId, iteration }, `AssemblyAI starting transcription [iteration:${iteration}]`);
+
+    // State tracking
+    let transcriptText = '';
+    let turnDetected = false;
+    let speechDetected = false;
+    let audioChunkCount = 0;
+    let totalAudioSamples = 0;
+    let isStreamExhausted = false;
+    let errorOccurred = false;
+    let errorMessage = '';
+    let maxDurationReached = false;
+    // For text modality input
+    let isTextInput = false;
+    let textContent: string | undefined;
+
+    // Get or create session
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = new AssemblyAISession(
+        sessionId,
+        this.apiKey,
+        this.buildWebSocketUrl(sessionId), // Pass sessionId to get dynamic eagerness settings
+        (id) => this.sessions.delete(id)
+      );
+      this.sessions.set(sessionId, session);
+    }
+
+    // Promise to capture the turn result
+    let turnResolve: (value: string) => void;
+    let turnReject: (error: any) => void;
+    let turnCompleted = false;
+    const turnPromise = new Promise<string>((resolve, reject) => {
+      turnResolve = resolve;
+      turnReject = reject;
+    });
+    const turnPromiseWithState = turnPromise.then((value) => {
+      turnCompleted = true;
+      return value;
+    });
+
+    // Assembly AI Callback handler
+    const messageHandler = (data: WebSocket.Data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        const msgType = message.type;
+
+        if (msgType === 'Turn') {
+          // Ignore turn events if we've already decided to stop
+          if (session?.shouldStopProcessing) {
+            return;
+          }
+
+          const transcript = message.transcript || '';
+          const utterance = message.utterance || '';
+          const isFinal = message.end_of_turn;
+
+          if (!transcript) return;
+
+          if (!isFinal) {
+            // Send partial transcript
+            const textToSend = utterance || transcript;
+            if (textToSend) {
+              this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
+
+              if (connection?.onSpeechDetected && !speechDetected) {
+                logger.info({ sessionId, iteration, interactionId: nextInteractionId }, `AssemblyAI speech detected [iteration:${iteration}]`);
+                speechDetected = true;
+                connection.onSpeechDetected(nextInteractionId);
+              }
+            }
+            return;
+          }
+
+          // Final transcript
+          logger.info({ sessionId, iteration, transcript }, `AssemblyAI turn detected ${formatSession(sessionId)} [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
+
+          transcriptText = transcript;
+          turnDetected = true;
+          if (session) session.shouldStopProcessing = true;
+          turnResolve(transcript);
+
+        } else if (msgType === 'Termination') {
+          logger.info({ sessionId, iteration }, `AssemblyAI session terminated ${formatSession(sessionId)} [iteration:${iteration}]`);
+        }
+      } catch (error) {
+        logger.error({ err: error, sessionId, iteration }, `AssemblyAI error handling message [iteration:${iteration}]`);
+      }
+    };
+
+    try {
+      // Ensure WebSocket connection is ready
+      await session.ensureConnection();
+
+      // Attach message handler
+      session.onMessage(messageHandler);
+
+      // Process multimodal content (audio chunks)
+      const audioProcessingPromise = (async () => {
+        let maxDurationTimeout: NodeJS.Timeout | null = null;
+        try {
+          logger.debug({ sessionId, iteration }, 'AssemblyAI WS STT - Starting multimodal processing loop');
+
+
+          // Safety timer: prevent infinite loops if no turn is detected
+          maxDurationTimeout = setTimeout(() => {
+            maxDurationReached = true; // Ensure maximum process() execution length doesn't exceed 40. If the player with an active mic does not speak for 60s, the node executor will error out thinking it's a zombie node
+            // We'll loop back in the graph and continue after timing out
+          }, this.MAX_TRANSCRIPTION_DURATION_MS);
+
+          while (true) {
+            if (session?.shouldStopProcessing) {
+              break;
+            }
+
+            if (maxDurationReached) {
+              if (!transcriptText) {
+                logger.warn({ sessionId, iteration }, `AssemblyAI max transcription duration reached [limit:${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`);
+                break;
+              }
+            }
+
+            const result = await multimodalStream.next();
+
+            if (result.done) {
+              logger.info({ sessionId, iteration, audioChunkCount }, `AssemblyAI multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`);
+              isStreamExhausted = true;
+              break;
+            }
+
+            if (session?.shouldStopProcessing) break;
+
+            const content = result.value as GraphTypes.MultimodalContent;
+
+            // Handle text input - immediately simulate turn detection
+            if (content.text !== undefined && content.text !== null) {
+              logger.info({ sessionId, iteration, text: content.text }, `AssemblyAI text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`);
+              isTextInput = true;
+              textContent = content.text;
+              transcriptText = content.text;
+              turnDetected = true;
+              if (session) session.shouldStopProcessing = true;
+              turnResolve(transcriptText);
+              // For text input, we immediately complete and bypass STT
+              break;
+            }
+
+            // Extract audio from MultimodalContent
+            if (content.audio === undefined || content.audio === null) {
+              continue;
+            }
+
+            const audioData = content.audio.data;
+            if (!audioData || audioData.length === 0) {
+              continue;
+            }
+
+            // Convert to Float32Array if needed
+            const float32Data = Array.isArray(audioData)
+              ? new Float32Array(audioData)
+              : audioData;
+
+            audioChunkCount++;
+            totalAudioSamples += float32Data.length;
+
+            const pcm16Data = float32ToPCM16(float32Data);
+
+            session?.sendAudio(pcm16Data);
+
+            if (audioChunkCount % 20 === 0) {
+               // Heartbeat log
+            }
+          }
+        } catch (error) {
+          logger.error({ err: error, sessionId, iteration }, `AssemblyAI error processing audio [iteration:${iteration}]`);
+          errorOccurred = true;
+          errorMessage = error instanceof Error ? error.message : String(error);
+          throw error;
+        } finally {
+          if (maxDurationTimeout) {
+            clearTimeout(maxDurationTimeout);
+          }
+        }
+      })();
+
+      const raceResult = await Promise.race([
+        turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
+        audioProcessingPromise.then(() => ({ winner: 'audio' as const })), // Audio will immediately win after the stream stops manually,
+      ]);
+
+      if (raceResult.winner === 'audio' && !turnCompleted && !maxDurationReached) { // and if audio wins, we enter this race, as turnComplete is not here yet
+        logger.info({ sessionId, iteration, timeout: this.TURN_COMPLETION_TIMEOUT_MS }, `AssemblyAI audio ended before turn [iteration:${iteration}], waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms for transcript`);
+
+        // Send 100ms of silence every 100ms to keep the connection alive/processing
+        const silenceIntervalMs = 100;
+        const silenceSamples = Math.floor((silenceIntervalMs / 1000) * this.sampleRate);
+        const silenceFrame = new Int16Array(silenceSamples);
+        const silenceTimer = setInterval(() => {
+          if (session && !session.shouldStopProcessing) {
+            session.sendAudio(silenceFrame);
+          }
+        }, silenceIntervalMs); // This is critical. Assembly AI Streaming API expects constant audio stream, or it will not emit any events.
+        // We need to continue streaming even if the user is not actively sending audio.
+
+        const timeoutPromise = new Promise<{ winner: 'timeout' }>((resolve) =>
+          setTimeout(() => resolve({ winner: 'timeout' }), this.TURN_COMPLETION_TIMEOUT_MS),
+        );
+
+        const waitResult = await Promise.race([
+          turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
+          timeoutPromise,
+        ]);
+
+        // We either timed out here or received a final turn event
+        clearInterval(silenceTimer);
+
+        if (waitResult.winner === 'timeout' && !turnCompleted) {
+          logger.warn({ sessionId, iteration }, `AssemblyAI timed out waiting for turn [iteration:${iteration}]`);
+          turnReject?.(new Error('Timed out waiting for turn completion'));
+        }
+      }
+
+      // Ensure the audio processing loop fully exits before returning
+      await audioProcessingPromise.catch(() => {});
+
+      logger.info({ sessionId, iteration, transcript: transcriptText }, `AssemblyAI transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`);
+
+      // Clear interactionId on turn completion
+      if (turnDetected) {
+        logger.info({ sessionId, iteration, interactionId: nextInteractionId }, 'AssemblyAI clearing interactionId after turn completion');
+        connection.state.interactionId = '';
+      }
+
+      // Tag the stream with type for runtime
+      const taggedStream = Object.assign(multimodalStream, {
+        type: 'MultimodalContent',
+        abort: () => {
+          // No-op abort handler
+        },
+      });
+
+      return new DataStreamWithMetadata(taggedStream as any, {
+        elementType: 'MultimodalContent',
+        iteration: iteration,
+        interactionId: nextInteractionId,
+        session_id: sessionId,
+        assembly_session_id: session.assemblySessionId,
+        transcript: transcriptText,
+        turn_detected: turnDetected,
+        audio_chunk_count: audioChunkCount,
+        total_audio_samples: totalAudioSamples,
+        sample_rate: this.sampleRate,
+        stream_exhausted: isStreamExhausted,
+        interaction_complete: turnDetected && transcriptText.length > 0,
+        error_occurred: errorOccurred,
+        error_message: errorMessage,
+        endpointing_latency_ms: 0,
+        // Flags to match native graph structure
+        is_running: !isStreamExhausted,
+        is_text_input: isTextInput,
+        is_interruption: false, // Not currently handling interruptions in this node
+        text_content: textContent,
+      });
+
+    } catch (error) {
+      logger.error({ err: error, sessionId, iteration }, `AssemblyAI transcription failed [iteration:${iteration}]`);
+
+      // Tag the stream with type for runtime
+      const taggedStream = Object.assign(multimodalStream, {
+        type: 'MultimodalContent',
+        abort: () => {
+          // No-op abort handler
+        },
+      });
+
+      return new DataStreamWithMetadata(taggedStream as any, {
+        elementType: 'MultimodalContent',
+        iteration: iteration,
+        interactionId: nextInteractionId,
+        session_id: sessionId,
+        assembly_session_id: session?.assemblySessionId || '',
+        transcript: '',
+        turn_detected: false,
+        audio_chunk_count: audioChunkCount,
+        total_audio_samples: totalAudioSamples,
+        sample_rate: this.sampleRate,
+        stream_exhausted: isStreamExhausted,
+        interaction_complete: false,
+        error_occurred: true,
+        error_message: error instanceof Error ? error.message : String(error),
+        endpointing_latency_ms: 0,
+        // Flags to match native graph structure
+        is_running: !isStreamExhausted,
+        is_text_input: isTextInput,
+        is_interruption: false, // Not currently handling interruptions in this node
+        text_content: textContent,
+      });
+    }
+    finally {
+      // Clean up message handler after execution ends
+      if (session) {
+        session.offMessage(messageHandler);
+      }
+    }
+  }
+
+  /**
+   * Send partial transcript update to the client for real-time feedback
+   */
+  private sendPartialTranscript(
+    sessionId: string,
+    interactionId: string,
+    text: string,
+  ): void {
+    const connection = this.connections[sessionId];
+    if (!connection || !connection.ws) {
+      return;
+    }
+
+    try {
+      if (connection.onPartialTranscript) {
+        connection.onPartialTranscript(text, interactionId);
+      }
+    } catch (error) {
+      logger.error({ err: error, sessionId }, 'AssemblyAI error sending partial transcript');
+    }
+  }
+
+  /**
+   * Update turn detection configuration for a specific session
+   */
+  updateTurnDetectionSettings(
+    sessionId: string,
+    settings: {
+      endOfTurnConfidenceThreshold: number;
+      minEndOfTurnSilenceWhenConfident: number;
+      maxTurnSilence: number;
+    }
+  ): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      logger.warn({ sessionId }, 'AssemblyAI cannot update settings: no active session');
+      return;
+    }
+
+    // Update the node's stored settings
+    this.endOfTurnConfidenceThreshold = settings.endOfTurnConfidenceThreshold;
+    this.minEndOfTurnSilenceWhenConfident = settings.minEndOfTurnSilenceWhenConfident;
+    this.maxTurnSilence = settings.maxTurnSilence;
+
+    logger.info({ sessionId, settings }, 'AssemblyAI updating turn detection');
+
+    // Send UpdateConfiguration message to active AssemblyAI WebSocket
+    session.updateConfiguration(settings);
+  }
+
+  /**
+   * Close a specific session by sessionId
+   */
+  async closeSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      logger.info(`[AssemblyAI WS STT] Closing session: ${sessionId}`);
+      await session.close();
+      this.sessions.delete(sessionId);
+      logger.info(`[AssemblyAI WS STT] Session ${sessionId} closed and removed`);
+    }
+  }
+
+  /**
+   * Clean up resources
+   */
+  async destroy(): Promise<void> {
+    logger.info({ sessionCount: this.sessions.size }, `AssemblyAI destroying node: closing ${this.sessions.size} WebSocket connections`);
+
+    const promises: Promise<void>[] = [];
+    for (const session of this.sessions.values()) {
+        promises.push(session.close());
+    }
+
+    await Promise.all(promises);
+    this.sessions.clear();
+    logger.info('AssemblyAI all sessions cleaned up');
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts b/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
new file mode 100644
index 0000000..28030b1
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
@@ -0,0 +1,87 @@
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+
+import { State } from '../../../types/index';
+
+/**
+ * DialogPromptBuilderNode builds a LLM chat request from the state.
+ *
+ * This node:
+ * - Receives the current conversation state
+ * - Converts state messages to LLM message format
+ * - Returns a formatted LLMChatRequest for the LLM node
+ */
+export class DialogPromptBuilderNode extends CustomNode {
+  process(_context: ProcessContext, state: State): GraphTypes.LLMChatRequest {
+    try {
+      logger.debug({ messageCount: state.messages?.length }, `DialogPromptBuilderNode start: ${state.messages?.length || 0} messages`);
+
+      // Convert state messages to LLMMessageInterface format
+      // Filter out messages with empty content
+      const conversationMessages = state.messages
+        .filter((msg) => {
+          if (!msg) {
+            logger.warn('DialogPromptBuilderNode - Found undefined message in state');
+            return false;
+          }
+          // Filter out messages with empty content
+          if (!msg.content || msg.content.trim() === '') {
+            logger.debug({ messageId: msg.id }, 'DialogPromptBuilderNode - Filtering out empty message');
+            return false;
+          }
+          return true;
+        })
+        .map((msg) => ({
+          role: msg.role,
+          content: msg.content,
+        }));
+
+      const request: any = {
+        messages: conversationMessages,
+      };
+
+      if (state.tools && Array.isArray(state.tools) && state.tools.length > 0) {
+        logger.debug({ toolCount: state.tools.length }, `DialogPromptBuilderNode processing ${state.tools.length} tools`);
+
+        // Transform OpenAI Realtime API format to Inworld SDK format
+        // OpenAI Realtime API: { type: 'function', name, description, parameters }
+        // Inworld SDK: { name, description, properties }
+        // The key difference: 'parameters' -> 'properties' (which is now a stringified JSON)
+        request.tools = state.tools
+          .filter((t: any) => t != null && typeof t === 'object')
+          .map((tool: any) => {
+            if (tool.type === 'function' && tool.name) {
+              return {
+                name: tool.name,
+                description: tool.description,
+                properties: JSON.stringify(tool.parameters || {}),
+              };
+            }
+            // If already in Inworld format or unknown, pass through
+            return tool;
+          });
+
+        logger.debug({ toolCount: request.tools.length }, `DialogPromptBuilderNode converted ${request.tools.length} tools to Inworld format`);
+
+        // Handle toolChoice - ensure it's in the right format
+        if (state.toolChoice) {
+          if (typeof state.toolChoice === 'string') {
+            request.toolChoice = { type: state.toolChoice };
+          } else {
+            request.toolChoice = state.toolChoice;
+          }
+        } else {
+          request.toolChoice = { type: 'auto' };
+        }
+
+        logger.debug({ toolChoice: request.toolChoice }, `DialogPromptBuilderNode tool choice: ${request.toolChoice}`);
+      }
+
+      logger.debug({ messageCount: conversationMessages.length }, `DialogPromptBuilderNode final request: ${conversationMessages.length} messages`);
+      return new GraphTypes.LLMChatRequest(request);
+    } catch (error) {
+      logger.error({ err: error }, 'DialogPromptBuilderNode fatal error');
+      throw error;
+    }
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts b/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
new file mode 100644
index 0000000..635d73e
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
@@ -0,0 +1,178 @@
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+import { formatSession, formatContext } from '../../../log-helpers';
+
+import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../../types/index';
+
+/**
+ * InteractionQueueNode manages the queue of user interactions.
+ *
+ * This node:
+ * - Receives interaction info from STT processing
+ * - Manages a queue of interactions to ensure sequential processing
+ * - Prevents race conditions when multiple interactions arrive
+ * - Returns TextInput when ready to process, or empty when waiting
+ *
+ * Queue states tracked in datastore:
+ * - 'q{id}': Queued interactions waiting to be processed
+ * - 'r{id}': Running interactions currently being processed
+ * - 'c{id}': Completed interactions
+ */
+export class InteractionQueueNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props?: {
+    id?: string;
+    connections?: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props?.id || 'interaction-queue-node',
+      reportToClient: props?.reportToClient,
+    });
+    this.connections = props?.connections || {};
+  }
+
+  process(
+    context: ProcessContext,
+    interactionInfo: InteractionInfo,
+    state: State,
+  ): TextInput {
+    const sessionId = interactionInfo.sessionId;
+    logger.debug({ sessionId, interactionId: interactionInfo.interactionId }, 'InteractionQueueNode processing');
+    
+    // Get current voiceId from connection state (in case it was updated via session.update)
+    const connection = this.connections[sessionId];
+    const currentVoiceId = connection?.state?.voiceId || state?.voiceId;
+
+    // ====================================================================
+    // STEP 1-3: Store text and analyze queue state
+    // ====================================================================
+    const dataStore = context.getDatastore();
+    const QUEUED_PREFIX = 'q';
+    const RUNNING_PREFIX = 'r';
+    const COMPLETED_PREFIX = 'c';
+
+    // Register interaction in the queue
+    if (!dataStore.has(QUEUED_PREFIX + interactionInfo.interactionId)) {
+      // Store queued interaction
+      dataStore.add(
+        QUEUED_PREFIX + interactionInfo.interactionId,
+        interactionInfo.text,
+      );
+      logger.info({ sessionId, interactionId: interactionInfo.interactionId }, 'InteractionQueue - New interaction queued');
+    }
+
+    // Get all keys and categorize them
+    const allKeys = dataStore.keys();
+    const queuedIds: string[] = [];
+    let completedCount = 0;
+    let runningCount = 0;
+
+    for (const key of allKeys) {
+      if (key.startsWith(QUEUED_PREFIX)) {
+        const idStr = key.substring(QUEUED_PREFIX.length);
+        queuedIds.push(idStr);
+      } else if (key.startsWith(COMPLETED_PREFIX)) {
+        completedCount++;
+      } else if (key.startsWith(RUNNING_PREFIX)) {
+        runningCount++;
+      }
+    }
+
+    // Sort queued IDs - extract iteration number for sorting
+    queuedIds.sort((a, b) => {
+      const getIteration = (id: string): number => {
+        const hashIndex = id.indexOf('#');
+        if (hashIndex === -1) return 0;
+        const iter = parseInt(id.substring(hashIndex + 1), 10);
+        return isNaN(iter) ? 0 : iter;
+      };
+      return getIteration(a) - getIteration(b);
+    });
+
+    logger.debug({
+      sessionId,
+      queuedCount: queuedIds.length,
+      completedCount,
+      runningCount,
+    }, 'InteractionQueue - State');
+
+    // ====================================================================
+    // STEP 4: Decide if we should start processing the next interaction
+    // ====================================================================
+    if (queuedIds.length === 0) {
+      // No interactions to process yet
+      logger.debug({ sessionId }, 'InteractionQueue - No interactions to process yet');
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      } as TextInput;
+    }
+
+    if (queuedIds.length === completedCount) {
+      // All interactions have been processed
+      logger.debug({ sessionId }, 'InteractionQueue - All interactions completed');
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      } as TextInput;
+    }
+
+    // There are unprocessed interactions
+    if (runningCount === completedCount) {
+      // No interaction is currently running, start the next one
+      const nextId = queuedIds[completedCount];
+      const runningKey = RUNNING_PREFIX + nextId;
+
+      // NOTE: We do NOT skip interactions marked as "interrupted"
+      // The "isInterrupted" flag means "this interaction caused an interruption of a previous response"
+      // But the user's speech is still a valid request that should be processed!
+      // All user speech should result in a response.
+
+      // Try to mark as running (prevents race conditions)
+      if (dataStore.has(runningKey) || !dataStore.add(runningKey, '')) {
+        logger.debug({ sessionId, interactionId: nextId }, 'InteractionQueue - Interaction already started');
+        return {
+          text: '',
+          sessionId: sessionId,
+          interactionId: '',
+          voiceId: currentVoiceId,
+        } as TextInput;
+      }
+
+      const queuedText = dataStore.get(QUEUED_PREFIX + nextId) as string;
+      if (!queuedText) {
+        logger.error({ sessionId, interactionId: nextId }, 'InteractionQueue - Failed to retrieve text');
+        return {
+          text: '',
+          sessionId: sessionId,
+          interactionId: '',
+          voiceId: currentVoiceId,
+        } as TextInput;
+      }
+
+      logger.info({ sessionId, interactionId: nextId, text: queuedText.substring(0, 100) }, `InteractionQueue - Starting LLM processing: "${queuedText.substring(0, 50)}..."`);
+
+      return {
+        text: queuedText,
+        sessionId: sessionId,
+        interactionId: nextId,
+        voiceId: currentVoiceId,
+      } as TextInput;
+    } else {
+      // An interaction is currently running, wait for it to complete
+      logger.debug({ sessionId, waitingForInteraction: queuedIds[completedCount] }, `InteractionQueue - Waiting for interaction [waiting for:${queuedIds[completedCount]}]`);
+      return {
+        text: '',
+        sessionId: sessionId,
+        interactionId: '',
+        voiceId: currentVoiceId,
+      } as TextInput;
+    }
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/state_update_node.ts b/realtime-service/src/components/graphs/nodes/state_update_node.ts
new file mode 100644
index 0000000..7f31c82
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/state_update_node.ts
@@ -0,0 +1,67 @@
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+import { formatSession, formatContext } from '../../../log-helpers';
+
+import { ConnectionsMap, State } from '../../../types/index';
+
+/**
+ * StateUpdateNode updates the state with the LLM's response.
+ *
+ * This node:
+ * - Receives the LLM output text
+ * - Updates the connection state with the assistant message
+ * - Marks the interaction as completed in the datastore
+ * - Returns the updated state
+ */
+export class StateUpdateNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+  }
+
+  process(context: ProcessContext, llmOutput: string): State {
+    const sessionId = context.getDatastore().get('sessionId') as string;
+    logger.debug({ sessionId, llmOutputLength: llmOutput?.length }, `StateUpdateNode processing [length:${llmOutput?.length || 0}]`);
+
+    // Get sessionId from dataStore (constant for graph execution)
+
+    const connection = this.connections[sessionId];
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId:${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId:${sessionId}`);
+    }
+
+    // Only add assistant message if there's actual content
+    // When LLM returns tool calls only, llmOutput is empty string
+    if (llmOutput && llmOutput.trim().length > 0) {
+      logger.debug({ sessionId, content: llmOutput.substring(0, 100) }, `StateUpdateNode adding assistant message: "${llmOutput.substring(0, 50)}..."`);
+      connection.state.messages.push({
+        role: 'assistant',
+        content: llmOutput,
+        id: connection.state.interactionId,
+      });
+    } else {
+      logger.debug({ sessionId }, 'StateUpdateNode skipping empty message (likely tool call only)');
+    }
+
+    const dataStore = context.getDatastore();
+    dataStore.add('c' + connection.state.interactionId, '');
+    logger.info({
+      sessionId,
+      interactionId: connection.state.interactionId,
+    }, `StateUpdateNode marking interaction completed ${formatContext(sessionId, undefined, connection.state.interactionId)}`);
+
+    return connection.state;
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/text_input_node.ts b/realtime-service/src/components/graphs/nodes/text_input_node.ts
new file mode 100644
index 0000000..311a7d0
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/text_input_node.ts
@@ -0,0 +1,75 @@
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+import { formatSession } from '../../../log-helpers';
+
+import { ConnectionsMap, State, TextInput } from '../../../types/index';
+import { TOOL_CALL_CONTINUATION_MARKER } from '../realtime_graph_executor';
+
+/**
+ * TextInputNode updates the state with the user's input this turn.
+ *
+ * This node:
+ * - Receives user text input with interaction and session IDs
+ * - Updates the connection state with the user message
+ * - Returns the updated state for downstream processing
+ * 
+ * Special handling for tool call continuation:
+ * - When text is TOOL_CALL_CONTINUATION_MARKER, this is a continuation after a tool call
+ * - In this case, we DON'T add a new user message (tool result is already in messages)
+ * - We just return the current state to trigger the LLM with existing conversation
+ */
+export class TextInputNode extends CustomNode {
+  private connections: ConnectionsMap;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+  }
+
+  process(context: ProcessContext, input: TextInput): State {
+    logger.debug({ sessionId: input.sessionId, text: input.text?.substring(0, 100) }, `TextInputNode processing: "${input.text?.substring(0, 50)}..."`);
+
+    const { text, interactionId, sessionId } = input;
+
+    const connection = this.connections[sessionId];
+    if (connection?.unloaded) {
+      throw Error(`Session unloaded for sessionId:${sessionId}`);
+    }
+    if (!connection) {
+      throw Error(`Failed to read connection for sessionId:${sessionId}`);
+    }
+    const state = connection.state;
+    if (!state) {
+      throw Error(
+        `Failed to read state from connection for sessionId:${sessionId}`,
+      );
+    }
+
+    // Update interactionId
+    connection.state.interactionId = interactionId;
+
+    // Check if this is a tool call continuation
+    // If so, the tool result is already in messages (added by createConversationItem)
+    // We skip adding a new user message and just return the state to continue the conversation
+    if (text === TOOL_CALL_CONTINUATION_MARKER) {
+      logger.info({ sessionId, interactionId }, 'TextInputNode: Tool call continuation - skipping user message, continuing with existing conversation');
+      return connection.state;
+    }
+
+    // Normal flow: add user message to conversation
+    connection.state.messages.push({
+      role: 'user',
+      content: text,
+      id: interactionId,
+    });
+
+    return connection.state;
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts b/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
new file mode 100644
index 0000000..ec6c6ac
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
@@ -0,0 +1,29 @@
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+
+import { ConnectionsMap, State, TextInput } from '../../../types/index';
+import {TextStream} from "@inworld/runtime";
+
+/**
+ * TextInputNode updates the state with the user's input this turn.
+ *
+ * This node:
+ * - Takes input from Text Chunking Node as a text stream
+ * - Outputs for graph handler to send to the client. Only used when modality is TextOnly
+ */
+export class TextOutputStreamNode extends CustomNode {
+    private connections: ConnectionsMap;
+
+    constructor(props: {
+        id: string;
+        connections: ConnectionsMap;
+    }) {
+        super({
+            id: props.id,
+        });
+        this.connections = props.connections;
+    }
+
+    process(context: ProcessContext, input: TextStream): TextStream {
+        return input;
+    }
+}
diff --git a/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts b/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
new file mode 100644
index 0000000..f3e8701
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
@@ -0,0 +1,63 @@
+import { DataStreamWithMetadata } from '@inworld/runtime';
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+import { formatContext } from '../../../log-helpers';
+
+import { InteractionInfo } from '../../../types/index';
+
+/**
+ * TranscriptExtractorNode extracts transcript information from
+ * DataStreamWithMetadata (typically output from AssemblyAISTTNode)
+ * and converts it to InteractionInfo for downstream processing.
+ *
+ * This is a helper node to bridge Assembly.AI STT output with
+ * the rest of the graph that expects InteractionInfo.
+ */
+export class TranscriptExtractorNode extends CustomNode {
+  constructor(props?: {
+    id?: string;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props?.id || 'transcript-extractor-node',
+      reportToClient: props?.reportToClient,
+    });
+  }
+
+  /**
+   * Extract transcript from metadata and return as InteractionInfo
+   */
+  process(
+    context: ProcessContext,
+    streamWithMetadata: DataStreamWithMetadata,
+  ): InteractionInfo {
+    const metadata = streamWithMetadata.getMetadata();
+    const sessionId = context.getDatastore().get('sessionId') as string;
+
+    // Extract transcript and related info from metadata
+    const transcript = (metadata.transcript as string) || '';
+    const interactionComplete =
+      (metadata.interaction_complete as boolean) || false;
+    const iteration = (metadata.iteration as number) || 1;
+    const interactionId = String(metadata.interactionId || iteration);
+
+    logger.info({
+      sessionId,
+      interactionId,
+      iteration,
+      interactionComplete,
+      transcript,
+    }, `TranscriptExtractor processing [iteration:${iteration}]: "${transcript?.substring(0, 50)}..."`);
+
+    // Return InteractionInfo
+    return {
+      sessionId,
+      interactionId: interactionId,
+      text: transcript,
+    };
+  }
+
+  async destroy(): Promise<void> {
+    // No cleanup needed
+  }
+}
diff --git a/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts b/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
new file mode 100644
index 0000000..f1a0c3a
--- /dev/null
+++ b/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
@@ -0,0 +1,64 @@
+import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
+import logger from '../../../logger';
+import { formatSession } from '../../../log-helpers';
+import { ConnectionsMap } from '../../../types/index';
+
+/**
+ * TTSRequestBuilderNode builds a TTSRequest with dynamic voiceId.
+ * For long-running graphs, it reads voiceId from connection state at processing time
+ * to ensure voice changes via session.update are reflected immediately.
+ */
+export class TTSRequestBuilderNode extends CustomNode {
+  private connections: ConnectionsMap;
+  private defaultVoiceId: string;
+
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    defaultVoiceId: string;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    this.connections = props.connections;
+    this.defaultVoiceId = props.defaultVoiceId;
+  }
+
+  /**
+   * Build a TTSRequest with the current voiceId from connection state
+   * Receives two inputs:
+   * 1. input - Graph input with sessionId (TextInput or State)
+   * 2. textStream - The text stream from TextChunkingNode
+   */
+  process(
+    context: ProcessContext,
+    input: any,
+    textStream: GraphTypes.TextStream,
+  ): GraphTypes.TTSRequest {
+    const sessionId = context.getDatastore().get('sessionId') as string;
+    
+    // For long-running graphs, read voiceId from connection state at processing time
+    // This ensures voice changes via session.update are immediately reflected
+    const connection = this.connections[sessionId];
+    const voiceId = connection?.state?.voiceId || input?.voiceId || this.defaultVoiceId;
+    
+    logger.debug({
+      sessionId,
+      voiceId,
+      connectionVoiceId: connection?.state?.voiceId,
+      inputVoiceId: input?.voiceId,
+      defaultVoiceId: this.defaultVoiceId,
+    }, `TTSRequestBuilder building request [voice:${voiceId}]`);
+
+    return GraphTypes.TTSRequest.withStream(textStream, {
+      id: voiceId
+    });
+  }
+
+  async destroy(): Promise<void> {
+    // No cleanup needed
+  }
+}
+
diff --git a/realtime-service/src/components/graphs/realtime_graph_executor.ts b/realtime-service/src/components/graphs/realtime_graph_executor.ts
new file mode 100644
index 0000000..f067470
--- /dev/null
+++ b/realtime-service/src/components/graphs/realtime_graph_executor.ts
@@ -0,0 +1,1180 @@
+import { GraphOutputStream, GraphTypes } from '@inworld/runtime/graph';
+import { v4 as uuidv4 } from 'uuid';
+import logger from '../../logger';
+import * as RT from '../../types/realtime';
+import { InworldApp } from '../app';
+import { RealtimeEventFactory } from '../realtime/realtime_event_factory';
+import { InworldGraphWrapper } from '../graphs/graph';
+import { Connection } from '../../types/index';
+import { convertToPCM16Base64 } from '../audio/audio_utils';
+import { ToolCallInterface } from "@inworld/runtime";
+import { RealtimeSessionManager } from '../realtime/realtime_session_manager';
+import { MultimodalStreamManager } from '../audio/multimodal_stream_manager';
+import { abortStream } from '../../helpers';
+
+// Marker used to signal tool call continuation - the graph nodes recognize this
+// and skip adding a new user message, instead continuing with existing conversation state
+export const TOOL_CALL_CONTINUATION_MARKER = '[TOOL_CALL_CONTINUATION]';
+
+export class RealtimeGraphExecutor {
+  private isCancelled = false;
+  private currentTTSInteractionId: string | null = null;
+  private currentTranscriptionItemId: string | null = null;
+  private partialTranscripts: Map<string, string> = new Map();
+
+  constructor(
+    private inworldApp: InworldApp,
+    private sessionKey: string,
+    private send: (data: RT.ServerEvent) => void,
+    private sessionManager: RealtimeSessionManager,
+    private sessionStartTime: number
+  ) { }
+
+  cancelCurrentResponse(reason: 'turn_detected' | 'client_cancelled'): void {
+    const realtimeSession = this.sessionManager.getSession();
+    if (!realtimeSession.currentResponse || this.isCancelled) {
+      return; // Nothing to cancel or already cancelled
+    }
+    logger.info({
+      sessionId: this.sessionKey,
+      reason,
+      responseId: realtimeSession.currentResponse.id,
+      ttsInteractionId: this.currentTTSInteractionId || 'none',
+    }, 'Response Cancellation');
+
+    this.isCancelled = true;
+    const response = realtimeSession.currentResponse;
+
+    // Abort active content and TTS streams
+    abortStream(realtimeSession.currentContentStream, 'content stream', this.sessionKey, 'due to response cancellation');
+    realtimeSession.currentContentStream = null;
+
+    abortStream(realtimeSession.currentTTSStream, 'TTS stream', this.sessionKey, 'due to response cancellation');
+    realtimeSession.currentTTSStream = null;
+
+    response.status = 'cancelled';
+    response.status_details = { type: 'cancelled', reason };
+
+    this.send(RealtimeEventFactory.responseDone(response));
+    realtimeSession.currentResponse = null;
+  }
+
+  /**
+   * Execute audio graph with streaming multimodal input (audio and/or text)
+   */
+  async executeAudioGraph({
+    sessionId,
+    workspaceId,
+    apiKey,
+    input,
+    graphWrapper,
+    multimodalStreamManager,
+  }: {
+    sessionId: string;
+    workspaceId: string;
+    apiKey: string;
+    input: { sessionId: string; state: any };
+    graphWrapper: InworldGraphWrapper;
+    multimodalStreamManager: MultimodalStreamManager;
+  }): Promise<void> {
+    // Create a multimodal stream generator that yields MultimodalContent
+    async function* multimodalStreamGenerator() {
+      for await (const content of multimodalStreamManager.createStream()) {
+        yield content;
+      }
+    }
+
+    // Create the tagged stream with metadata
+    const taggedStream = Object.assign(multimodalStreamGenerator(), {
+      type: 'MultimodalContent',
+    });
+
+    const { outputStream } = await graphWrapper.graph.start(taggedStream, {
+      executionId: input.sessionId,
+      dataStoreContent: {
+        sessionId: input.sessionId,
+        state: input.state,
+      },
+      userContext: {
+        attributes: {
+          workspaceId: workspaceId,
+        },
+        targetingKey: uuidv4(),
+      },
+      userCredentials: {
+        inworldApiKey: apiKey,
+      },
+    });
+
+    const connection = this.inworldApp.connections[sessionId];
+    if (!connection) {
+      logger.debug({ sessionId }, 'Connection no longer exists, aborting audio graph execution');
+      outputStream.abort();
+      return;
+    }
+
+    // Store the execution stream so it can be aborted if needed
+    connection.currentAudioExecutionStream = outputStream;
+
+    // Handle multiple interactions from the stream
+    try {
+      let currentGraphInteractionId: string | undefined = undefined;
+      let resultCount = 0;
+
+      for await (const result of outputStream) {
+        resultCount++;
+        logger.debug({ sessionId, resultCount }, `Processing audio interaction #${resultCount}`);
+
+        // Check if result contains an error
+        if (result && result.isGraphError && result.isGraphError()) {
+          const errorData = result.data;
+          logger.error({
+            sessionId,
+            err: errorData,
+          }, 'Graph error');
+          if (!errorData.message.includes('recognition produced no text')) {
+            this.send(
+              RealtimeEventFactory.error({
+                type: 'graph_error',
+                message: errorData.message,
+              }),
+            );
+            if (errorData.code === 4) {
+              const connection = this.inworldApp.connections[sessionId];
+              if (connection?.ws) {
+                // Close the websocket connection
+                // Using code 1011 (Internal Error) as it's a server-side error
+                connection.ws.close(1011, 'JS Call Timeout. We will end the call if the audio stream is not active in 60 seconds.');
+              }
+            }
+          }
+          continue;
+        }
+
+        // Process the result - this will handle transcription, LLM response, and TTS
+        await this.processAudioGraphOutput(
+          result,
+          connection,
+          sessionId,
+          currentGraphInteractionId,
+        );
+      }
+
+      logger.info({ sessionId, resultCount }, `Audio stream processing complete: ${resultCount} interactions`);
+    } catch (error) {
+      logger.error({ err: error, sessionId }, 'Error processing audio stream');
+      throw error;
+    } finally {
+      // Clear the stream reference when done (if connection still exists)
+      const conn = this.inworldApp.connections[sessionId];
+      if (conn && conn.currentAudioExecutionStream === outputStream) {
+        conn.currentAudioExecutionStream = undefined;
+      }
+      // Clean up stream manager
+      connection.multimodalStreamManager = undefined;
+      connection.currentAudioGraphExecution = undefined;
+    }
+  }
+
+  /**
+   * Process a single result from the audio graph
+   */
+  private async processAudioGraphOutput(
+    result: any,
+    connection: Connection,
+    sessionId: string,
+    currentGraphInteractionId: string | undefined,
+  ): Promise<void> {
+    try {
+      logger.debug({
+        sessionId,
+        handlers: Object.keys(result),
+      }, 'Audio Graph Result - Processing result');
+
+      const realtimeSession = this.sessionManager.getSession();
+
+      await result.processResponse({
+        Content: async (content: GraphTypes.Content) => {
+          logger.debug({
+            sessionId,
+            hasContent: !!content.content,
+            contentLength: content.content?.length,
+            hasToolCalls: !!content.toolCalls,
+            toolCallsCount: content.toolCalls?.length,
+          }, 'Audio Graph - Content received');
+
+          if (content.toolCalls && content.toolCalls.length > 0) {
+            logger.info({ sessionId, toolCalls: content.toolCalls }, `Audio Graph - ${content.toolCalls.length} tool calls received`);
+          }
+        },
+        ContentStream: async (stream: GraphTypes.ContentStream) => {
+          // Ensure we have a response object
+          if (!realtimeSession.currentResponse) {
+            const responseId = uuidv4();
+            const response: RT.Response = {
+              id: responseId,
+              object: 'realtime.response',
+              status: 'in_progress',
+              status_details: null,
+              output: [],
+              conversation_id: 'conv_' + realtimeSession.id,
+              output_modalities: realtimeSession.session.output_modalities,
+              max_output_tokens: realtimeSession.session.max_output_tokens,
+              audio: {
+                output: realtimeSession.session.audio.output,
+              },
+              usage: null,
+              metadata: null,
+            };
+            realtimeSession.currentResponse = response;
+            this.send(RealtimeEventFactory.responseCreated(response));
+          }
+
+          await this.handleContentStream(stream, realtimeSession.currentResponse!, connection);
+        },
+        TTSOutputStream: async (ttsStream: GraphTypes.TTSOutputStream) => {
+          // Create a response if we don't have one
+          if (!realtimeSession.currentResponse) {
+            const responseId = uuidv4();
+            const response: RT.Response = {
+              id: responseId,
+              object: 'realtime.response',
+              status: 'in_progress',
+              status_details: null,
+              output: [],
+              conversation_id: 'conv_' + realtimeSession.id,
+              output_modalities: realtimeSession.session.output_modalities,
+              max_output_tokens: realtimeSession.session.max_output_tokens,
+              audio: {
+                output: realtimeSession.session.audio.output,
+              },
+              usage: null,
+              metadata: null,
+            };
+            realtimeSession.currentResponse = response;
+            this.send(RealtimeEventFactory.responseCreated(response));
+          }
+
+          await this.handleTTSOutputStream(ttsStream, realtimeSession.currentResponse!, connection, 'Audio Input');
+        },
+        TextStream: async (stream: GraphTypes.TextStream) => {
+          // Create a response if we don't have one
+          if (!realtimeSession.currentResponse) {
+            const responseId = uuidv4();
+            const response: RT.Response = {
+              id: responseId,
+              object: 'realtime.response',
+              status: 'in_progress',
+              status_details: null,
+              output: [],
+              conversation_id: 'conv_' + realtimeSession.id,
+              output_modalities: realtimeSession.session.output_modalities,
+              max_output_tokens: realtimeSession.session.max_output_tokens,
+              audio: {
+                output: realtimeSession.session.audio.output,
+              },
+              usage: null,
+              metadata: null,
+            };
+            realtimeSession.currentResponse = response;
+            this.send(RealtimeEventFactory.responseCreated(response));
+          }
+          await this.handleTextOutputStream(stream, realtimeSession.currentResponse!, connection, 'Audio Input');
+        },
+        Custom: async (customData: GraphTypes.Custom<any>) => {
+          // Handle custom events (transcription, etc)
+
+          // Check if it's a transcription event
+          if (('text' in customData || customData.type === 'TRANSCRIPT') && !('messages' in customData)) {
+            const transcript = (customData as any).text || '';
+            const interactionId = (customData as any).interactionId;
+            const isTextInput = (customData as any).is_text_input === true;
+
+            // Skip tool continuation marker - this is an internal marker, not a real transcript
+            if (transcript === TOOL_CALL_CONTINUATION_MARKER) {
+              logger.info({ sessionId, interactionId }, 
+                'Skipping transcription event for tool call continuation marker');
+              return;
+            }
+
+            if (transcript && transcript.trim().length > 0) {
+              const itemId = interactionId || uuidv4();
+              
+              // Check if this is a text input (simulated) - if so, skip transcription events
+              // Text inputs already have their conversation item created before being pushed to the graph
+              // We check:
+              // 1. If is_text_input flag is set in customData
+              // 2. If a conversation item with matching text already exists (text inputs create items first)
+              // 3. If the most recent user message matches this transcript (text inputs are processed immediately)
+              const existingItem = realtimeSession.conversationItems.find(
+                item => item.id === itemId || 
+                (item.role === 'user' && 
+                 item.content?.[0]?.type === 'input_text' && 
+                 item.content[0].text === transcript)
+              );
+              
+              // Also check the most recent user message (text inputs are typically the last item)
+              const lastUserItem = realtimeSession.conversationItems.length > 0
+                ? realtimeSession.conversationItems[realtimeSession.conversationItems.length - 1]
+                : null;
+              const isRecentTextInput = lastUserItem?.role === 'user' &&
+                lastUserItem?.content?.[0]?.type === 'input_text' &&
+                lastUserItem.content[0].text === transcript;
+
+              if (isTextInput || existingItem || isRecentTextInput) {
+                // This is a text input that was already processed
+                // Skip all transcription events since the conversation item already exists
+                logger.info({ sessionId, itemId, transcript: transcript.substring(0, 50) }, 
+                  `Skipping transcription events for text input (conversation item already exists)`);
+                return;
+              }
+
+              const audioStartMs = Date.now() - this.sessionStartTime;
+
+              // Send speech started event if we haven't already
+              if (!this.currentTranscriptionItemId) {
+                this.send(
+                  RealtimeEventFactory.inputAudioBufferSpeechStarted(audioStartMs, itemId),
+                );
+              }
+
+              this.currentTranscriptionItemId = itemId;
+
+              // Send speech stopped event
+              const audioEndMs = Date.now() - this.sessionStartTime;
+              this.send(
+                RealtimeEventFactory.inputAudioBufferSpeechStopped(audioEndMs, itemId),
+              );
+
+              const previousItemId =
+                realtimeSession.conversationItems.length > 0
+                  ? realtimeSession.conversationItems[
+                    realtimeSession.conversationItems.length - 1
+                  ].id
+                  : null;
+
+              // Send committed event
+              this.send(
+                RealtimeEventFactory.inputAudioBufferCommitted(itemId, previousItemId),
+              );
+
+              // Create conversation item for user transcription
+              const item: RT.ConversationItem = {
+                id: itemId,
+                type: 'message',
+                object: 'realtime.item',
+                status: 'completed',
+                role: 'user',
+                content: [
+                  {
+                    type: 'input_text',
+                    text: transcript,
+                  },
+                ],
+              };
+
+              realtimeSession.conversationItems.push(item);
+              this.send(RealtimeEventFactory.conversationItemAdded(item, previousItemId));
+
+              // Send transcription completed event
+              logger.info({ sessionId, transcript, itemId }, `Transcription completed: "${transcript.substring(0, 50)}..."`);
+              this.send(
+                RealtimeEventFactory.inputAudioTranscriptionCompleted(
+                  itemId,
+                  0,
+                  transcript,
+                ),
+              );
+
+              this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
+
+              // Clear the transcription item ID
+              this.currentTranscriptionItemId = null;
+              this.partialTranscripts.delete(itemId);
+            }
+          }
+        },
+        error: async (error: GraphTypes.GraphError) => {
+          logger.error({ sessionId, err: error }, 'Graph error');
+          // Don't send errors for empty speech recognition
+          if (!error.message.includes('recognition produced no text')) {
+            this.send(
+              RealtimeEventFactory.error({
+                type: 'server_error',
+                message: error.message,
+              }),
+            );
+          }
+        },
+      });
+    } catch (error) {
+      logger.error({ sessionId, err: error }, 'Error processing audio graph result');
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'server_error',
+          message: error instanceof Error ? error.message : 'Unknown error processing audio graph result',
+        }),
+      );
+    }
+  }
+
+  /**
+   * Process ContentStream for tool calls (shared between audio and text graphs)
+   */
+  private async handleContentStream(
+    stream: GraphTypes.ContentStream,
+    response: RT.Response,
+    connection: Connection,
+  ): Promise<void> {
+    const realtimeSession = this.sessionManager.getSession();
+    const toolCallState = new Map<string, { item: RT.ConversationItem; args: string }>();
+
+    // Store the stream object so it can be aborted
+    realtimeSession.currentContentStream = stream;
+
+    try {
+      for await (const chunk of stream) {
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+          await this.handleToolCallChunk(chunk.toolCalls, response, toolCallState);
+        }
+      }
+    } finally {
+      // Clear the stream reference when done
+      realtimeSession.currentContentStream = null;
+    }
+
+    // Send completion events for all tool calls
+    for (const [callId, state] of toolCallState.entries()) {
+      const outputIndex = response.output.indexOf(state.item);
+
+      // Update the item with final arguments
+      state.item.arguments = state.args;
+      state.item.status = 'completed';
+
+      // Send done event
+      this.send(
+        RealtimeEventFactory.responseFunctionCallArgumentsDone(
+          response.id,
+          state.item.id!,
+          outputIndex,
+          callId,
+          state.args,
+        ),
+      );
+
+      this.send(
+        RealtimeEventFactory.conversationItemDone(state.item),
+      );
+
+      this.send(
+        RealtimeEventFactory.responseOutputItemDone(
+          response.id,
+          outputIndex,
+          state.item,
+        ),
+      );
+
+      // Add to conversation items
+      realtimeSession.conversationItems.push(state.item);
+
+      // Add a minimal assistant message
+      connection.state.messages.push({
+        role: 'assistant',
+        content: '[Function call executed]',
+        id: connection.state.interactionId,
+      });
+    }
+  }
+
+  /**
+   * Process TextOutputStream for text-only messages
+   */
+  private async handleTextOutputStream(
+    stream: GraphTypes.TextStream,
+    response: RT.Response,
+    connection: Connection,
+    logPrefix: string,
+  ): Promise<RT.ConversationItem | undefined> {
+    const realtimeSession = this.sessionManager.getSession();
+    const isTextOnly =
+      response.output_modalities?.includes('text') &&
+      !response.output_modalities?.includes('audio');
+
+    let item: RT.ConversationItem | undefined;
+    let itemId: string | undefined;
+    let outputIndex: number | undefined;
+    let contentPart: RT.ContentPart | undefined;
+    const contentIndex = 0;
+
+    if (!isTextOnly) {
+      logger.info('[Text Output Stream] should not be called when modality is not text only!');
+      return item;
+    }
+
+    // Process text stream chunks
+    for await (const chunk of stream) {
+      // Extract text from chunk (handle both string and object with text property)
+      const text = typeof chunk === 'string' ? chunk : (chunk?.text || chunk?.toString() || '');
+
+      if (!text || text === '') {
+        continue;
+      }
+
+      // Lazy create item on first chunk
+      if (!item) {
+        itemId = uuidv4();
+        outputIndex = response.output.length;
+
+        item = {
+          id: itemId,
+          type: 'message',
+          object: 'realtime.item',
+          status: 'in_progress',
+          role: 'assistant',
+          content: [],
+        };
+
+        const previousItemId =
+          realtimeSession.conversationItems.length > 0
+            ? realtimeSession.conversationItems[
+              realtimeSession.conversationItems.length - 1
+            ].id
+            : null;
+
+        response.output.push(item);
+        this.send(
+          RealtimeEventFactory.responseOutputItemAdded(response.id, outputIndex, item),
+        );
+        this.send(
+          RealtimeEventFactory.conversationItemAdded(item, previousItemId),
+        );
+
+        contentPart = { type: 'text', text: '' };
+
+        item.content = [contentPart];
+        this.send(
+          RealtimeEventFactory.responseContentPartAdded(
+            response.id,
+            itemId,
+            outputIndex,
+            contentIndex,
+            contentPart,
+          ),
+        );
+
+        // Track that we're streaming text for this interaction
+        const textInteractionId = connection.state.interactionId;
+        this.isCancelled = false;
+
+        logger.info({ sessionId: this.sessionKey, textInteractionId, logPrefix }, `Text stream starting (${logPrefix})`);
+      }
+
+      if (this.isCancelled) {
+        logger.info(`[Text Output] Stopping text stream - response was cancelled`);
+        break;
+      }
+
+      // Send text delta event
+      this.send(
+        RealtimeEventFactory.responseTextDelta(
+          response.id,
+          itemId!,
+          outputIndex!,
+          contentIndex,
+          text,
+        ),
+      );
+      // logger.info(`[TEXT DELTA] - ${text}`);
+      contentPart!.text = (contentPart!.text || '') + text;
+    }
+
+    // Send completion events or mark as incomplete
+    if (item) {
+      if (this.isCancelled) {
+        item.status = 'incomplete';
+      } else {
+        const previousItemId =
+          realtimeSession.conversationItems.length > 0
+            ? realtimeSession.conversationItems[
+              realtimeSession.conversationItems.length - 1
+            ].id
+            : null;
+
+        // Send text completion event
+        this.send(RealtimeEventFactory.responseTextDone(
+          response.id, itemId!, outputIndex!, contentIndex, contentPart!.text || ''
+        ));
+
+        // Send common completion events
+        this.send(RealtimeEventFactory.responseContentPartDone(
+          response.id, itemId!, outputIndex!, contentIndex, contentPart!
+        ));
+        this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
+
+        item.status = 'completed';
+        this.send(RealtimeEventFactory.responseOutputItemDone(response.id, outputIndex!, item));
+      }
+
+      // Add to conversation items
+      realtimeSession.conversationItems.push(item);
+    }
+
+    return item;
+  }
+
+  /**
+   * Process TTSOutputStream for audio messages
+   * Note: Text-only modality is handled by handleTextOutputStream
+   */
+  private async handleTTSOutputStream(
+    ttsStream: GraphTypes.TTSOutputStream,
+    response: RT.Response,
+    connection: Connection,
+    logPrefix: string,
+  ): Promise<RT.ConversationItem | undefined> {
+    const realtimeSession = this.sessionManager.getSession();
+    const isTextOnly =
+      response.output_modalities?.includes('text') &&
+      !response.output_modalities?.includes('audio');
+
+    // Warn if called with text-only modality (should use handleTextOutputStream instead)
+    if (isTextOnly) {
+      logger.warn('[TTS Output Stream] Called with text-only modality - should use handleTextOutputStream instead');
+    }
+
+    let item: RT.ConversationItem | undefined;
+    let itemId: string | undefined;
+    let outputIndex: number | undefined;
+    let contentPart: RT.ContentPart | undefined;
+    const contentIndex = 0;
+
+    // Store the TTSOutputStream object so it can be aborted using its abort() method
+    realtimeSession.currentTTSStream = ttsStream;
+
+    try {
+      // Process TTS stream chunks
+      for await (const chunk of ttsStream) {
+        // Lazy create item on first chunk
+        if (!item) {
+          itemId = uuidv4();
+          outputIndex = response.output.length;
+
+          item = {
+            id: itemId,
+            type: 'message',
+            object: 'realtime.item',
+            status: 'in_progress',
+            role: 'assistant',
+            content: [],
+          };
+
+          const previousItemId =
+            realtimeSession.conversationItems.length > 0
+              ? realtimeSession.conversationItems[
+                realtimeSession.conversationItems.length - 1
+              ].id
+              : null;
+
+          response.output.push(item);
+          this.send(
+            RealtimeEventFactory.responseOutputItemAdded(response.id, outputIndex, item),
+          );
+          this.send(
+            RealtimeEventFactory.conversationItemAdded(item, previousItemId),
+          );
+
+          // Always create audio content part (text-only is handled elsewhere)
+          contentPart = { type: 'audio', transcript: '' };
+
+          item.content = [contentPart];
+          this.send(
+            RealtimeEventFactory.responseContentPartAdded(
+              response.id,
+              itemId,
+              outputIndex,
+              contentIndex,
+              contentPart,
+            ),
+          );
+
+          // Track that we're streaming TTS for this interaction
+          const ttsInteractionId = connection.state.interactionId;
+          this.currentTTSInteractionId = ttsInteractionId;
+          this.isCancelled = false;
+
+          logger.info(`[TTS] Starting stream for ${ttsInteractionId} (${logPrefix})`);
+        }
+
+        if (this.isCancelled) {
+          logger.info(`[TTS] Stopping TTS stream - response was cancelled`);
+          break;
+        }
+
+        // Process audio chunk
+        if (chunk.text != null && chunk.text !== '') {
+          this.send(
+            RealtimeEventFactory.responseAudioTranscriptDelta(
+              response.id,
+              itemId!,
+              outputIndex!,
+              contentIndex,
+              chunk.text,
+            ),
+          );
+        }
+
+        // Convert audio data to PCM16 base64
+        const audioBase64 = convertToPCM16Base64(
+          chunk.audio?.data,
+          chunk.audio?.sampleRate,
+          `TTS Audio (${logPrefix})`
+        );
+
+        if (!audioBase64) {
+          continue;
+        }
+
+        // Send audio delta
+        this.send(
+          RealtimeEventFactory.responseAudioDelta(
+            response.id,
+            itemId!,
+            outputIndex!,
+            contentIndex,
+            audioBase64,
+          ),
+        );
+
+        // Update transcript
+        if (chunk.text) {
+          contentPart!.transcript = (contentPart!.transcript || '') + chunk.text;
+        }
+      }
+
+      // Send completion events or mark as incomplete
+      if (item) {
+        if (this.isCancelled) {
+          item.status = 'incomplete';
+        } else {
+          const previousItemId =
+            realtimeSession.conversationItems.length > 0
+              ? realtimeSession.conversationItems[
+                realtimeSession.conversationItems.length - 1
+              ].id
+              : null;
+
+          // Send audio completion events
+          this.send(RealtimeEventFactory.responseAudioTranscriptDone(
+            response.id, itemId!, outputIndex!, contentIndex, contentPart!.transcript || ''
+          ));
+          this.send(RealtimeEventFactory.responseAudioDone(
+            response.id, itemId!, outputIndex!, contentIndex
+          ));
+
+          // Send common completion events
+          this.send(RealtimeEventFactory.responseContentPartDone(
+            response.id, itemId!, outputIndex!, contentIndex, contentPart!
+          ));
+          this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
+
+          item.status = 'completed';
+          this.send(RealtimeEventFactory.responseOutputItemDone(response.id, outputIndex!, item));
+
+          // Clear TTS tracking on successful completion
+          this.currentTTSInteractionId = null;
+        }
+
+        // Add to conversation items
+        realtimeSession.conversationItems.push(item);
+      }
+
+      return item;
+    } catch (error) {
+      // Check if this is a cancellation error (expected when response is cancelled)
+      const isCancellationError =
+        this.isCancelled &&
+        error instanceof Error &&
+        error.message.includes('Operation cancelled');
+
+      if (isCancellationError) {
+        logger.debug({ sessionId: this.sessionKey }, 'TTS stream cancelled (expected during response cancellation)');
+
+        // Mark item as incomplete if we had started creating one
+        if (item) {
+          item.status = 'incomplete';
+          realtimeSession.conversationItems.push(item);
+        }
+        return item;
+      }
+
+      // Re-throw unexpected errors
+      throw error;
+    } finally {
+      // Clear the stream reference when done
+      realtimeSession.currentTTSStream = null;
+    }
+  }
+
+  /**
+   * Handle tool call chunks from LLM stream
+   */
+  private async handleToolCallChunk(
+    toolCalls: ToolCallInterface[],
+    response: RT.Response,
+    toolCallState: Map<string, { item: RT.ConversationItem; args: string }>,
+  ): Promise<void> {
+    for (const toolCall of toolCalls) {
+      const callId = toolCall.id;
+
+      if (!toolCallState.has(callId)) {
+        // New tool call
+        const itemId = uuidv4();
+        const outputIndex = response.output.length;
+        const item: RT.ConversationItem = {
+          id: itemId,
+          type: 'function_call',
+          object: 'realtime.item',
+          status: 'in_progress',
+          call_id: callId,
+          name: toolCall.name,
+          arguments: '',
+        };
+
+        response.output.push(item);
+        this.send(
+          RealtimeEventFactory.responseOutputItemAdded(
+            response.id,
+            outputIndex,
+            item,
+          ),
+        );
+        this.send(RealtimeEventFactory.conversationItemAdded(item));
+
+        toolCallState.set(callId, { item, args: toolCall.args || '' });
+
+        if (toolCall.args) {
+          this.send(
+            RealtimeEventFactory.responseFunctionCallArgumentsDelta(
+              response.id,
+              item.id!,
+              outputIndex,
+              callId,
+              toolCall.args,
+            ),
+          );
+        }
+      } else {
+        // Existing tool call
+        const state = toolCallState.get(callId)!;
+
+        if (toolCall.args) {
+          state.args += toolCall.args;
+
+          const outputIndex = response.output.indexOf(state.item);
+
+          this.send(
+            RealtimeEventFactory.responseFunctionCallArgumentsDelta(
+              response.id,
+              state.item.id!,
+              outputIndex,
+              callId,
+              toolCall.args,
+            ),
+          );
+        }
+      }
+    }
+  }
+
+  /**
+   * Handle partial transcription updates from AssemblyAI.
+   */
+  handlePartialTranscriptDelta(
+    interactionId: string,
+    text: string,
+  ): void {
+    if (!interactionId || typeof text !== 'string') {
+      return;
+    }
+
+    const previous = this.partialTranscripts.get(interactionId) ?? '';
+
+    if (text === previous) {
+      return;
+    }
+
+    // Track that this interaction is the active transcription
+    this.currentTranscriptionItemId = interactionId;
+
+    // Compute the longest common prefix to determine the delta
+    const commonPrefixLength = this.getCommonPrefixLength(previous, text);
+    const deletions = previous.length - commonPrefixLength;
+    let delta = '';
+
+    if (deletions > 0) {
+      delta += '\b'.repeat(deletions);
+    }
+
+    delta += text.slice(commonPrefixLength);
+
+    if (!delta) {
+      return;
+    }
+
+    this.partialTranscripts.set(interactionId, text);
+
+    this.send(
+      RealtimeEventFactory.inputAudioTranscriptionDelta(
+        interactionId,
+        0,
+        delta,
+      ),
+    );
+  }
+
+  private getCommonPrefixLength(a: string, b: string): number {
+    const maxLen = Math.min(a.length, b.length);
+    let idx = 0;
+    while (idx < maxLen && a[idx] === b[idx]) {
+      idx++;
+    }
+    return idx;
+  }
+
+  /**
+   * Create a response from the model
+   */
+  async createResponse(inputItemId?: string): Promise<void> {
+    // Reset cancellation flag for new response
+    this.isCancelled = false;
+
+    const realtimeSession = this.sessionManager.getSession();
+    const responseId = uuidv4();
+    const response: RT.Response = {
+      id: responseId,
+      object: 'realtime.response',
+      status: 'in_progress',
+      status_details: null,
+      output: [],
+      conversation_id: 'conv_' + realtimeSession.id,
+      output_modalities: realtimeSession.session.output_modalities,
+      max_output_tokens: realtimeSession.session.max_output_tokens,
+      audio: {
+        output: realtimeSession.session.audio.output,
+      },
+      usage: null,
+      metadata: null,
+    };
+
+    realtimeSession.currentResponse = response;
+    this.send(RealtimeEventFactory.responseCreated(response));
+
+    try {
+      const connection = this.inworldApp.connections[this.sessionKey];
+      
+      // Check if this is a tool call continuation (response.create after function_call_output)
+      const lastItem = realtimeSession.conversationItems.length > 0
+        ? realtimeSession.conversationItems[realtimeSession.conversationItems.length - 1]
+        : null;
+      
+      const isToolCallContinuation = lastItem?.type === 'function_call_output';
+      
+      if (isToolCallContinuation) {
+        // This is a continuation after a tool call - the tool result is already in connection.state.messages
+        // We need to trigger the LLM with the current conversation state
+        logger.info({ sessionId: this.sessionKey, callId: lastItem.call_id }, 'Tool call continuation - triggering LLM with tool result');
+        
+        if (!connection) {
+          throw new Error('No connection found for session');
+        }
+        
+        // Trigger the LLM via the audio graph with a tool continuation marker
+        // This will be recognized by the graph and processed without adding a new user message
+        await this.handleToolCallContinuation(connection, response);
+        return;
+      }
+
+      // Find the most recent user message to process
+      let userMessage: RT.ConversationItem | undefined;
+
+      if (inputItemId) {
+        userMessage = realtimeSession.conversationItems.find(
+          (i) => i.id === inputItemId,
+        );
+      } else {
+        // Find the last user message
+        for (let i = realtimeSession.conversationItems.length - 1; i >= 0; i--) {
+          const item = realtimeSession.conversationItems[i];
+          if (item.role === 'user') {
+            userMessage = item;
+            break;
+          }
+        }
+      }
+
+      if (!userMessage || !userMessage.content || userMessage.content.length === 0) {
+        // Send error event instead of throwing
+        response.status = 'failed';
+        response.status_details = {
+          type: 'failed',
+          error: {
+            type: 'invalid_request_error',
+            code: 'no_user_message',
+          },
+        };
+        this.send(RealtimeEventFactory.responseDone(response));
+        this.send(
+          RealtimeEventFactory.error({
+            type: 'invalid_request_error',
+            code: 'no_user_message',
+            message: 'No user message found to generate response. Please create a conversation item before requesting a response.',
+          }),
+        );
+        realtimeSession.currentResponse = null;
+        return;
+      }
+
+      const content = userMessage.content[0];
+      let input: any;
+
+      if (content.type === 'input_text' && content.text) {
+        // Text inputs are processed through the continuous multimodal stream
+        // The graph runs continuously and automatically sends response events for each turn
+        // DO NOT wait for graph completion - it runs until the stream is ended
+        const hasActiveAudioGraph = connection?.currentAudioGraphExecution !== undefined;
+        
+        if (hasActiveAudioGraph) {
+          // Graph is running and processing text turns continuously
+          // Response events are sent automatically by processAudioGraphOutput
+          // Just acknowledge and return - don't block
+          logger.info({ sessionId: this.sessionKey, responseId },
+            'Text input being processed by continuous graph - response events sent automatically');
+        } else {
+          // No active graph - text should have been pushed via conversation.item.create first
+          logger.warn({ sessionId: this.sessionKey },
+            'No active graph for text input - ensure conversation.item.create was called first');
+        }
+
+        // Cancel this response.create since the graph handles responses automatically
+        this.isCancelled = true;
+        realtimeSession.currentResponse = null;
+        return;
+      } else {
+        // For audio input, it should have been handled by the audio graph already?
+        // Or if we manually trigger response creation on an existing audio item?
+        // If content.type is input_audio, we probably can't easily re-run it through the text graph
+        // unless we have the transcript.
+        // But the logic in original file threw error.
+        throw new Error(`Unsupported content type: ${content.type}`);
+      }
+
+      // Don't mark as completed if already cancelled
+      if (!this.isCancelled) {
+        // Mark response as completed
+        response.status = 'completed';
+        response.status_details = { type: 'completed' };
+      }
+    } catch (error) {
+      logger.error({ err: error, sessionId: this.sessionKey }, 'Error creating response');
+      response.status = 'failed';
+      response.status_details = {
+        type: 'failed',
+        error: {
+          type: 'server_error',
+          code: 'internal_error',
+        },
+      };
+      // Send error to websocket
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'server_error',
+          message: error instanceof Error ? error.message : 'Error creating response',
+        }),
+      );
+    }
+
+    // Only send response.done if not already cancelled
+    if (!this.isCancelled) {
+      this.send(RealtimeEventFactory.responseDone(response));
+      realtimeSession.currentResponse = null;
+    }
+  }
+
+  /**
+   * Handle tool call continuation by triggering the LLM with the current conversation state.
+   * The tool result is already in connection.state.messages (added by createConversationItem).
+   * This method triggers the graph without adding a new user message.
+   */
+  private async handleToolCallContinuation(
+    connection: Connection,
+    response: RT.Response,
+  ): Promise<void> {
+    const realtimeSession = this.sessionManager.getSession();
+    
+    try {
+      // Create a multimodal stream manager for this continuation
+      const multimodalStreamManager = new MultimodalStreamManager();
+      connection.multimodalStreamManager = multimodalStreamManager;
+      
+      const session = realtimeSession.session;
+      
+      // Start the audio graph execution with the stream
+      const audioStreamInput = {
+        sessionId: this.sessionKey,
+        state: connection.state,
+        voiceId: connection.state.voiceId || session.audio.output.voice,
+      };
+      
+      // Use the Assembly.AI audio graph
+      const graphWrapper = this.inworldApp.graphWithAudioInput;
+      
+      // Push a special tool continuation marker that the graph nodes will recognize
+      // This signals that we're continuing after a tool call and shouldn't add a new user message
+      multimodalStreamManager.pushText(TOOL_CALL_CONTINUATION_MARKER);
+      
+      // Start graph execution and wait for completion
+      connection.currentAudioGraphExecution = this.executeAudioGraph({
+        sessionId: this.sessionKey,
+        workspaceId: connection.workspaceId,
+        apiKey: connection.apiKey,
+        input: audioStreamInput,
+        graphWrapper,
+        multimodalStreamManager,
+      });
+      
+      await connection.currentAudioGraphExecution;
+      
+      // Response should have been handled by the audio graph output processing
+      // Mark as completed if not already done
+      if (!this.isCancelled && realtimeSession.currentResponse?.id === response.id) {
+        response.status = 'completed';
+        response.status_details = { type: 'completed' };
+        this.send(RealtimeEventFactory.responseDone(response));
+        realtimeSession.currentResponse = null;
+      }
+    } catch (error) {
+      logger.error({ err: error, sessionId: this.sessionKey }, 'Error in tool call continuation');
+      response.status = 'failed';
+      response.status_details = {
+        type: 'failed',
+        error: {
+          type: 'server_error',
+          code: 'tool_continuation_error',
+        },
+      };
+      this.send(RealtimeEventFactory.responseDone(response));
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'server_error',
+          message: error instanceof Error ? error.message : 'Error in tool call continuation',
+        }),
+      );
+      realtimeSession.currentResponse = null;
+    } finally {
+      // Clean up
+      connection.multimodalStreamManager = undefined;
+      connection.currentAudioGraphExecution = undefined;
+    }
+  }
+}
+
diff --git a/realtime-service/src/components/realtime/realtime_event_factory.ts b/realtime-service/src/components/realtime/realtime_event_factory.ts
new file mode 100644
index 0000000..1e94d4e
--- /dev/null
+++ b/realtime-service/src/components/realtime/realtime_event_factory.ts
@@ -0,0 +1,499 @@
+import { v4 as uuidv4 } from 'uuid';
+import * as RT from '../../types/realtime';
+
+/**
+ * Factory for creating OpenAI Realtime API server events
+ */
+export class RealtimeEventFactory {
+  /**
+   * Create a session.created event
+   */
+  static sessionCreated(session: RT.Session): RT.SessionCreatedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'session.created',
+      session,
+    };
+  }
+
+  /**
+   * Create a session.updated event
+   */
+  static sessionUpdated(session: RT.Session): RT.SessionUpdatedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'session.updated',
+      session,
+    };
+  }
+
+  /**
+   * Create a conversation.item.added event
+   */
+  static conversationItemAdded(
+    item: RT.ConversationItem,
+    previousItemId: string | null = null,
+  ): RT.ConversationItemAddedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.added',
+      previous_item_id: previousItemId,
+      item,
+    };
+  }
+
+  /**
+   * Create a conversation.item.done event
+   */
+  static conversationItemDone(
+    item: RT.ConversationItem,
+    previousItemId: string | null = null,
+  ): RT.ConversationItemDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.done',
+      previous_item_id: previousItemId,
+      item,
+    };
+  }
+
+  /**
+   * Create a conversation.item.retrieved event
+   */
+  static conversationItemRetrieved(
+    item: RT.ConversationItem,
+  ): RT.ConversationItemRetrievedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.retrieved',
+      item,
+    };
+  }
+
+  /**
+   * Create a conversation.item.truncated event
+   */
+  static conversationItemTruncated(
+    itemId: string,
+    contentIndex: number,
+    audioEndMs: number,
+  ): RT.ConversationItemTruncatedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.truncated',
+      item_id: itemId,
+      content_index: contentIndex,
+      audio_end_ms: audioEndMs,
+    };
+  }
+
+  /**
+   * Create a conversation.item.deleted event
+   */
+  static conversationItemDeleted(
+    itemId: string,
+  ): RT.ConversationItemDeletedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.deleted',
+      item_id: itemId,
+    };
+  }
+
+  /**
+   * Create an input_audio_buffer.speech_started event
+   */
+  static inputAudioBufferSpeechStarted(
+    audioStartMs: number,
+    itemId: string,
+  ): RT.InputAudioBufferSpeechStartedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'input_audio_buffer.speech_started',
+      audio_start_ms: audioStartMs,
+      item_id: itemId,
+    };
+  }
+
+  /**
+   * Create an input_audio_buffer.speech_stopped event
+   */
+  static inputAudioBufferSpeechStopped(
+    audioEndMs: number,
+    itemId: string,
+  ): RT.InputAudioBufferSpeechStoppedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'input_audio_buffer.speech_stopped',
+      audio_end_ms: audioEndMs,
+      item_id: itemId,
+    };
+  }
+
+  /**
+   * Create an input_audio_buffer.committed event
+   */
+  static inputAudioBufferCommitted(
+    itemId: string,
+    previousItemId: string | null = null,
+  ): RT.InputAudioBufferCommittedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'input_audio_buffer.committed',
+      previous_item_id: previousItemId,
+      item_id: itemId,
+    };
+  }
+
+  /**
+   * Create an input_audio_buffer.cleared event
+   */
+  static inputAudioBufferCleared(): RT.InputAudioBufferClearedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'input_audio_buffer.cleared',
+    };
+  }
+
+  /**
+   * Create a conversation.item.input_audio_transcription.delta event
+   */
+  static inputAudioTranscriptionDelta(
+    itemId: string,
+    contentIndex: number,
+    delta: string,
+  ): RT.ConversationItemInputAudioTranscriptionDeltaEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.input_audio_transcription.delta',
+      item_id: itemId,
+      content_index: contentIndex,
+      delta,
+    };
+  }
+
+  /**
+   * Create a conversation.item.input_audio_transcription.completed event
+   */
+  static inputAudioTranscriptionCompleted(
+    itemId: string,
+    contentIndex: number,
+    transcript: string,
+  ): RT.ConversationItemInputAudioTranscriptionCompletedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'conversation.item.input_audio_transcription.completed',
+      item_id: itemId,
+      content_index: contentIndex,
+      transcript,
+    };
+  }
+
+  /**
+   * Create a response.created event
+   */
+  static responseCreated(response: RT.Response): RT.ResponseCreatedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.created',
+      response,
+    };
+  }
+
+
+  /**
+   * Create a response.done event
+   */
+  static responseDone(response: RT.Response): RT.ResponseDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.done',
+      response,
+    };
+  }
+
+  /**
+   * Create a response.output_item.added event
+   */
+  static responseOutputItemAdded(
+    responseId: string,
+    outputIndex: number,
+    item: RT.ConversationItem,
+  ): RT.ResponseOutputItemAddedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_item.added',
+      response_id: responseId,
+      output_index: outputIndex,
+      item,
+    };
+  }
+
+  /**
+   * Create a response.output_item.done event
+   */
+  static responseOutputItemDone(
+    responseId: string,
+    outputIndex: number,
+    item: RT.ConversationItem,
+  ): RT.ResponseOutputItemDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_item.done',
+      response_id: responseId,
+      output_index: outputIndex,
+      item,
+    };
+  }
+
+  /**
+   * Create a response.content_part.added event
+   */
+  static responseContentPartAdded(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    part: RT.ContentPart,
+  ): RT.ResponseContentPartAddedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.content_part.added',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      part,
+    };
+  }
+
+  /**
+   * Create a response.content_part.done event
+   */
+  static responseContentPartDone(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    part: RT.ContentPart,
+  ): RT.ResponseContentPartDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.content_part.done',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      part,
+    };
+  }
+
+  /**
+   * Create a response.output_audio.delta event
+   */
+  static responseAudioDelta(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    delta: string,
+  ): RT.ResponseAudioDeltaEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_audio.delta',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      delta,
+    };
+  }
+
+  /**
+   * Create a response.output_audio.done event
+   */
+  static responseAudioDone(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+  ): RT.ResponseAudioDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_audio.done',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+    };
+  }
+
+  /**
+   * Create a response.output_audio_transcript.delta event
+   */
+  static responseAudioTranscriptDelta(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    delta: string,
+  ): RT.ResponseAudioTranscriptDeltaEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_audio_transcript.delta',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      delta,
+    };
+  }
+
+  /**
+   * Create a response.output_audio_transcript.done event
+   */
+  static responseAudioTranscriptDone(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    transcript: string,
+  ): RT.ResponseAudioTranscriptDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_audio_transcript.done',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      transcript,
+    };
+  }
+
+  /**
+   * Create a response.function_call_arguments.delta event
+   */
+  static responseFunctionCallArgumentsDelta(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    callId: string,
+    delta: string,
+  ): RT.ResponseFunctionCallArgumentsDeltaEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.function_call_arguments.delta',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      call_id: callId,
+      delta,
+    };
+  }
+
+  /**
+   * Create a response.function_call_arguments.done event
+   */
+  static responseFunctionCallArgumentsDone(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    callId: string,
+    args: string,
+  ): RT.ResponseFunctionCallArgumentsDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.function_call_arguments.done',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      call_id: callId,
+      arguments: args,
+    };
+  }
+
+  /**
+   * Create a response.output_text.delta event
+   */
+  static responseTextDelta(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    delta: string,
+  ): RT.ResponseTextDeltaEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_text.delta',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      delta,
+    };
+  }
+
+  /**
+   * Create a response.output_text.done event
+   */
+  static responseTextDone(
+    responseId: string,
+    itemId: string,
+    outputIndex: number,
+    contentIndex: number,
+    text: string,
+  ): RT.ResponseTextDoneEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'response.output_text.done',
+      response_id: responseId,
+      item_id: itemId,
+      output_index: outputIndex,
+      content_index: contentIndex,
+      text,
+    };
+  }
+
+  /**
+   * Create an error event
+   */
+  static error(
+    error: {
+      type: string;
+      code?: string;
+      message: string;
+      param?: string;
+      event_id?: string;
+    },
+  ): RT.ErrorEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'error',
+      error: {
+        type: error.type,
+        code: error.code || null,
+        message: error.message,
+        param: error.param || null,
+        event_id: error.event_id || null,
+      },
+    };
+  }
+
+  /**
+   * Create a rate_limits.updated event
+   */
+  static rateLimitsUpdated(
+    rateLimits: Array<{
+      name: 'requests' | 'tokens';
+      limit: number;
+      remaining: number;
+      reset_seconds: number;
+    }>,
+  ): RT.RateLimitsUpdatedEvent {
+    return {
+      event_id: uuidv4(),
+      type: 'rate_limits.updated',
+      rate_limits: rateLimits,
+    };
+  }
+}
diff --git a/realtime-service/src/components/realtime/realtime_message_handler.ts b/realtime-service/src/components/realtime/realtime_message_handler.ts
new file mode 100644
index 0000000..7b35140
--- /dev/null
+++ b/realtime-service/src/components/realtime/realtime_message_handler.ts
@@ -0,0 +1,168 @@
+import { RawData } from 'ws';
+import logger from '../../logger';
+import { formatContext, formatSession, formatError } from '../../log-helpers';
+import * as RT from '../../types/realtime';
+import { InworldApp } from '../app';
+import { RealtimeEventFactory } from './realtime_event_factory';
+import { RealtimeSessionManager } from './realtime_session_manager';
+import { RealtimeAudioHandler } from '../audio/realtime_audio_handler';
+import { RealtimeGraphExecutor } from '../graphs/realtime_graph_executor';
+
+export class RealtimeMessageHandler {
+  private sessionManager: RealtimeSessionManager;
+  private audioHandler: RealtimeAudioHandler;
+  private graphExecutor: RealtimeGraphExecutor;
+  private processingQueue: (() => Promise<void>)[] = [];
+  private isProcessing = false;
+  private sessionStartTime: number = Date.now();
+
+  constructor(
+    private inworldApp: InworldApp,
+    private sessionKey: string,
+    private send: (data: RT.ServerEvent) => void,
+  ) {
+    this.sessionManager = new RealtimeSessionManager(inworldApp, sessionKey, send, this.sessionStartTime);
+    this.graphExecutor = new RealtimeGraphExecutor(inworldApp, sessionKey, send, this.sessionManager, this.sessionStartTime);
+    this.audioHandler = new RealtimeAudioHandler(inworldApp, sessionKey, send, this.graphExecutor, this.sessionManager);
+  }
+
+  async initialize(): Promise<void> {
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (connection) {
+      connection.state.voiceId = this.sessionManager.getSession().session.audio.output.voice;
+
+      connection.onSpeechDetected = (interactionId: string) => {
+        logger.info(
+          { interactionId, sessionId: this.sessionKey },
+          `Speech detected ${formatContext(this.sessionKey, undefined, interactionId)}`
+        );
+
+        this.send(RealtimeEventFactory.inputAudioBufferSpeechStarted(
+          Date.now() - this.sessionStartTime, // audio_start_ms
+          interactionId // item_id
+        ));
+      };
+
+      // Partial transcript callback
+      connection.onPartialTranscript = (text: string, interactionId: string) => {
+        this.graphExecutor.handlePartialTranscriptDelta(interactionId, text);
+      };
+    }
+
+    this.send(RealtimeEventFactory.sessionCreated(this.sessionManager.getSession().session));
+  }
+
+  /**
+   * Handle incoming WebSocket messages
+   */
+  async handleMessage(data: RawData): Promise<void> {
+    try {
+      const event = JSON.parse(data.toString()) as RT.ClientEvent;
+
+      // Handle these events immediately without queuing:
+
+      // 1. Cancellation - needs to stop ongoing response generation immediately
+      if (event.type === 'response.cancel') {
+        logger.info({
+          sessionId: this.sessionKey,
+          responseId: event.response_id,
+        }, `Cancelling response with id: ${event.response_id}`);
+        this.graphExecutor.cancelCurrentResponse('client_cancelled');
+        return;
+      }
+
+      // 2. Audio append - needs to flow continuously without blocking
+      if (event.type === 'input_audio_buffer.append') {
+        await this.audioHandler.handleInputAudioBufferAppend(event);
+        return;
+      }
+
+      // Add all other events to the queue to ensure sequential processing
+      this.addToQueue(async () => {
+        try {
+          switch (event.type) {
+            case 'session.update':
+              await this.sessionManager.updateSession(event);
+              break;
+
+            case 'input_audio_buffer.commit':
+              await this.audioHandler.handleInputAudioBufferCommit(event);
+              break;
+
+            case 'input_audio_buffer.clear':
+              await this.audioHandler.handleInputAudioBufferClear(event);
+              break;
+
+            case 'conversation.item.create':
+              await this.sessionManager.createConversationItem(event, this.audioHandler);
+              break;
+
+            case 'conversation.item.truncate':
+              await this.sessionManager.truncateConversationItem(event);
+              break;
+
+            case 'conversation.item.delete':
+              await this.sessionManager.deleteConversationItem(event);
+              break;
+
+            case 'conversation.item.retrieve':
+              await this.sessionManager.retrieveConversationItem(event);
+              break;
+
+            case 'response.create':
+              await this.graphExecutor.createResponse();
+              break;
+
+            default:
+              logger.warn({ eventType: (event as any).type, sessionId: this.sessionKey }, `Unknown event type: ${(event as any).type}`);
+          }
+        } catch (error) {
+          logger.error({ err: error, sessionId: this.sessionKey }, 'Error handling queued message');
+          this.send(
+            RealtimeEventFactory.error({
+              type: 'invalid_request_error',
+              message: error.message,
+            }),
+          );
+        }
+      });
+    } catch (error) {
+      logger.error({ err: error, sessionId: this.sessionKey }, 'Error parsing message');
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          message: 'Failed to parse message',
+        }),
+      );
+    }
+  }
+
+  /**
+   * Add task to processing queue
+   */
+  private addToQueue(task: () => Promise<void>): void {
+    this.processingQueue.push(task);
+    this.processQueue();
+  }
+
+  /**
+   * Process queued tasks
+   */
+  private async processQueue(): Promise<void> {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.processingQueue.length > 0) {
+      const task = this.processingQueue.shift();
+      if (task) {
+        try {
+          await task();
+        } catch (error) {
+          logger.error({ err: error, sessionId: this.sessionKey }, 'Error processing task from queue');
+        }
+      }
+    }
+    this.isProcessing = false;
+  }
+}
diff --git a/realtime-service/src/components/realtime/realtime_session_manager.ts b/realtime-service/src/components/realtime/realtime_session_manager.ts
new file mode 100644
index 0000000..aa46204
--- /dev/null
+++ b/realtime-service/src/components/realtime/realtime_session_manager.ts
@@ -0,0 +1,508 @@
+import { v4 as uuidv4 } from 'uuid';
+import logger from '../../logger';
+import { formatSession, formatContext } from '../../log-helpers';
+import * as RT from '../../types/realtime';
+import { InworldApp } from '../app';
+import { RealtimeEventFactory } from './realtime_event_factory';
+import { Connection } from '../../types/index';
+import { getAssemblyAISettingsForEagerness } from '../../types/settings';
+import { RealtimeAudioHandler } from '../audio/realtime_audio_handler';
+
+export class RealtimeSessionManager {
+  realtimeSession: RT.RealtimeSession;
+  private sessionStartTime: number;
+
+  constructor(
+    private inworldApp: InworldApp,
+    private sessionKey: string,
+    private send: (data: RT.ServerEvent) => void,
+    sessionStartTime: number
+  ) {
+    this.sessionStartTime = sessionStartTime;
+    this.realtimeSession = this.createDefaultSession();
+  }
+
+  getSession(): RT.RealtimeSession {
+    return this.realtimeSession;
+  }
+
+
+  /**
+   * Create a default session configuration
+   */
+  private createDefaultSession(): RT.RealtimeSession {
+    const sessionId = uuidv4();
+
+    const connection = this.inworldApp.connections[this.sessionKey];
+    const instructions = connection?.state?.agent
+      ? `You are: "${connection.state.agent.name}". Your persona is: "${connection.state.agent.description}". Your motivation is: "${connection.state.agent.motivation}".`
+      : 'You are a helpful AI assistant.';
+
+    // Session expires in 15 minutes (900 seconds)
+    const expiresAt = Math.floor(Date.now() / 1000) + 900;
+
+    const defaultOutputModalities: ('text' | 'audio')[] = ['audio', 'text'];
+    
+    // Sync default to connection state
+    if (connection) {
+      connection.state.output_modalities = defaultOutputModalities;
+    }
+    
+    return {
+      id: sessionId,
+      session: {
+        type: 'realtime',
+        id: sessionId,
+        object: 'realtime.session',
+        model: this.inworldApp.llmModelName,
+        output_modalities: defaultOutputModalities,
+        instructions,
+        audio: {
+          input: {
+            format: {
+              type: 'audio/pcm',
+              rate: 24000,
+            },
+            transcription: null,
+            noise_reduction: null,
+            turn_detection: {
+              type: 'semantic_vad',
+              eagerness: 'medium',
+              create_response: true,
+              interrupt_response: true,
+            },
+          },
+          output: {
+            format: {
+              type: 'audio/pcm',
+              rate: 24000,
+            },
+            voice: this.inworldApp.voiceId,
+            speed: 1,
+          },
+        },
+        tools: [],
+        tool_choice: 'auto',
+        temperature: 0.8,
+        max_output_tokens: 'inf',
+        truncation: 'auto',
+        prompt: null,
+        tracing: null,
+        expires_at: expiresAt,
+        include: null,
+      },
+      conversationItems: [],
+      inputAudioBuffer: [],
+      currentResponse: null,
+      audioStartMs: 0,
+      currentContentStream: null,
+      currentTTSStream: null,
+    };
+  }
+
+  /**
+   * Handle session.update event
+   */
+  async updateSession(event: RT.SessionUpdateEvent): Promise<void> {
+    const sessionConfig = event.session;
+
+    // Deep merge session configuration
+    if (sessionConfig.output_modalities !== undefined) {
+      this.realtimeSession.session.output_modalities = sessionConfig.output_modalities;
+      
+      // Sync to connection state for easy access by sessionId
+      const connection = this.inworldApp.connections[this.sessionKey];
+      if (connection) {
+        connection.state.output_modalities = sessionConfig.output_modalities;
+        logger.info({
+          sessionId: this.sessionKey,
+          output_modalities: sessionConfig.output_modalities,
+          state_modalities: connection.state.output_modalities
+        }, `Updated connection.state.output_modalities`);
+      } else {
+        logger.warn({ sessionId: this.sessionKey }, `No connection found when updating output_modalities`);
+      }
+    }
+
+    if (sessionConfig.instructions !== undefined) {
+      this.realtimeSession.session.instructions = sessionConfig.instructions;
+
+      // Inject system instructions as the first message in the conversation state
+      const connection = this.inworldApp.connections[this.sessionKey];
+      if (connection && sessionConfig.instructions) {
+        // Check if there's already a system message at the start
+        const hasSystemMessage =
+          connection.state.messages.length > 0 &&
+          connection.state.messages[0].role === 'system';
+
+        if (hasSystemMessage) {
+          // Update existing system message
+          connection.state.messages[0].content = sessionConfig.instructions;
+          logger.info({ sessionId: this.sessionKey }, 'Updated system instructions');
+        } else {
+          // Insert new system message at the beginning
+          connection.state.messages.unshift({
+            id: 'system_instructions',
+            role: 'system',
+            content: sessionConfig.instructions,
+          });
+          logger.info({ sessionId: this.sessionKey }, 'Injected system instructions');
+        }
+      }
+    }
+
+    if (sessionConfig.audio) {
+      // Merge audio input configuration
+      if (sessionConfig.audio.input) {
+        if (sessionConfig.audio.input.format) {
+          this.realtimeSession.session.audio.input.format = {
+            ...this.realtimeSession.session.audio.input.format,
+            ...sessionConfig.audio.input.format,
+          };
+        }
+        if (sessionConfig.audio.input.transcription !== undefined) {
+          this.realtimeSession.session.audio.input.transcription = sessionConfig.audio.input.transcription;
+        }
+        if (sessionConfig.audio.input.noise_reduction !== undefined) {
+          this.realtimeSession.session.audio.input.noise_reduction = sessionConfig.audio.input.noise_reduction;
+        }
+        if (sessionConfig.audio.input.turn_detection !== undefined) {
+          if (sessionConfig.audio.input.turn_detection === null) {
+            this.realtimeSession.session.audio.input.turn_detection = null;
+          } else {
+            this.realtimeSession.session.audio.input.turn_detection = {
+              ...this.realtimeSession.session.audio.input.turn_detection,
+              ...sessionConfig.audio.input.turn_detection,
+            };
+            
+            // Handle semantic_vad eagerness settings
+            if (sessionConfig.audio.input.turn_detection.type === 'semantic_vad') {
+              const eagerness = sessionConfig.audio.input.turn_detection.eagerness;
+              if (eagerness && eagerness !== 'auto') {
+                const connection = this.inworldApp.connections[this.sessionKey];
+                if (connection) {
+                  const normalizedEagerness = eagerness as 'low' | 'medium' | 'high';
+                  connection.state.eagerness = normalizedEagerness;
+                  logger.info({ sessionId: this.sessionKey, eagerness }, `Updated eagerness to ${eagerness}`);
+
+                  // Dynamically update AssemblyAI turn detection settings on the active graph
+                  const assemblyAINode = this.inworldApp.graphWithAudioInput?.assemblyAINode;
+                  if (assemblyAINode) {
+                    const assemblySettings = getAssemblyAISettingsForEagerness(normalizedEagerness);
+                    // Extract only the numeric settings for updateTurnDetectionSettings
+                    const { endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence } = assemblySettings;
+                    logger.info({ sessionId: this.sessionKey, endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence }, `Applying eagerness settings: threshold=${endOfTurnConfidenceThreshold}`);
+                    assemblyAINode.updateTurnDetectionSettings(
+                        this.sessionKey,
+                        { endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence }
+                    )
+                  } else {
+                    logger.warn({ sessionId: this.sessionKey }, 'AssemblyAI node not found, settings will apply on next audio input');
+                    this.send(
+                        RealtimeEventFactory.error({
+                          type: 'invalid_request_error',
+                          code: 'no_STT_session',
+                          message: `Server did not find active STT connection. Turning on Mic to start audio stream input session.`,
+                          event_id: event.event_id,
+                        }),
+                    );
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Merge audio output configuration
+      if (sessionConfig.audio.output) {
+        if (sessionConfig.audio.output.format) {
+          this.realtimeSession.session.audio.output.format = {
+            ...this.realtimeSession.session.audio.output.format,
+            ...sessionConfig.audio.output.format,
+          };
+        }
+        if (sessionConfig.audio.output.voice !== undefined) {
+          this.realtimeSession.session.audio.output.voice = sessionConfig.audio.output.voice;
+
+          // Store voice in connection state for TTS node
+          const connection = this.inworldApp.connections[this.sessionKey];
+          if (connection) {
+            connection.state.voiceId = sessionConfig.audio.output.voice;
+            logger.info({ sessionId: this.sessionKey, voice: sessionConfig.audio.output.voice }, `Updated TTS voice to ${sessionConfig.audio.output.voice}`);
+          }
+        }
+        if (sessionConfig.audio.output.speed !== undefined) {
+          this.realtimeSession.session.audio.output.speed = sessionConfig.audio.output.speed;
+        }
+      }
+    }
+
+    if (sessionConfig.tools !== undefined) {
+      this.realtimeSession.session.tools = sessionConfig.tools;
+
+      // Update connection state with tools
+      const connection = this.inworldApp.connections[this.sessionKey];
+      if (connection) {
+        connection.state.tools = sessionConfig.tools;
+      }
+    }
+
+    if (sessionConfig.tool_choice !== undefined) {
+      this.realtimeSession.session.tool_choice = sessionConfig.tool_choice;
+
+      // Update connection state with toolChoice
+      const connection = this.inworldApp.connections[this.sessionKey];
+      if (connection) {
+        connection.state.toolChoice = sessionConfig.tool_choice;
+      }
+    }
+
+    if (sessionConfig.temperature !== undefined) {
+      this.realtimeSession.session.temperature = sessionConfig.temperature;
+    }
+
+    if (sessionConfig.max_output_tokens !== undefined) {
+      this.realtimeSession.session.max_output_tokens = sessionConfig.max_output_tokens;
+    }
+
+    if (sessionConfig.truncation !== undefined) {
+      this.realtimeSession.session.truncation = sessionConfig.truncation;
+    }
+
+    if (sessionConfig.prompt !== undefined) {
+      this.realtimeSession.session.prompt = sessionConfig.prompt;
+    }
+
+    if (sessionConfig.tracing !== undefined) {
+      this.realtimeSession.session.tracing = sessionConfig.tracing;
+    }
+
+    if (sessionConfig.include !== undefined) {
+      this.realtimeSession.session.include = sessionConfig.include;
+    }
+
+    // Send session.updated event
+    this.send(RealtimeEventFactory.sessionUpdated(this.realtimeSession.session));
+  }
+
+  /**
+   * Handle conversation.item.create event
+   */
+  async createConversationItem(
+    event: RT.ConversationItemCreateEvent,
+    audioHandler?: RealtimeAudioHandler,
+  ): Promise<void> {
+    const item = {
+      ...event.item,
+      id: event.item.id || uuidv4(),
+      object: 'realtime.item' as const,
+      status: event.item.status || ('completed' as const),
+    };
+
+    this.realtimeSession.conversationItems.push(item);
+    this.send(
+      RealtimeEventFactory.conversationItemAdded(item, event.previous_item_id),
+    );
+    this.send(
+      RealtimeEventFactory.conversationItemDone(item, event.previous_item_id),
+    );
+    
+    // Add to conversation state so LLM is aware of this item
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (connection) {
+      // Handle different item types
+      if (item.type === 'function_call_output') {
+        // Function call output received
+        const functionOutputItem = item as RT.FunctionCallOutputItem;
+        logger.info({
+          sessionId: this.sessionKey,
+          call_id: functionOutputItem.call_id,
+          output: functionOutputItem.output,
+        }, 'Function output received');
+        
+        // Add a system message to inform the LLM that the function was executed
+        // The Inworld SDK/Groq combo doesn't properly support 'tool' role with tool_call_id
+        // So we use a system message to provide context about the function execution
+        connection.state.messages.push({
+          role: 'system',
+          content: `[SYSTEM] Function executed. Result: ${functionOutputItem.output}`,
+          id: item.id,
+        });
+        
+        logger.info({ sessionId: this.sessionKey }, 'Added function execution result to conversation');
+      } else if (item.type === 'message') {
+        // Handle message items
+        const messageItem = item as RT.MessageItem;
+        if (messageItem.content && messageItem.content.length > 0) {
+          const content = messageItem.content[0];
+          let textContent = '';
+          
+          if (content.type === 'input_text') {
+            textContent = content.text || '';
+          } else if (content.type === 'text') {
+            textContent = content.text || '';
+          } else if (content.type === 'input_audio') {
+            // Audio inputs should already be handled by STT
+            return;
+          }
+          
+          if (textContent) {
+            logger.info({
+              sessionId: this.sessionKey,
+              role: messageItem.role,
+              contentPreview: textContent.substring(0, 100),
+            }, `Adding ${messageItem.role} message: ${textContent.substring(0, 50)}...`);
+            // We don't need to call connection.state.messages.push here. That's handled in the graph's input node
+          }
+
+          // If it's a text input, push it to the audio graph
+          if (content.type === 'input_text' && content.text && audioHandler) {
+            await audioHandler.handleTextInput(content.text);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Handle conversation.item.truncate event
+   */
+  async truncateConversationItem(
+    event: RT.ConversationItemTruncateEvent,
+  ): Promise<void> {
+    // Find the item
+    const item = this.realtimeSession.conversationItems.find(
+      (i) => i.id === event.item_id,
+    );
+
+    if (!item) {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          code: 'item_not_found',
+          message: `Item with id ${event.item_id} not found`,
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    // Only assistant message items can be truncated
+    if (item.role !== 'assistant') {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          code: 'invalid_item_type',
+          message: 'Only assistant message items can be truncated',
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    // Truncate the content part at the specified index
+    if (item.content && item.content[event.content_index]) {
+      const contentPart = item.content[event.content_index];
+      
+      // If it's an audio content part, truncate the audio and remove transcript
+      if (contentPart.type === 'audio' && contentPart.audio) {
+        // Note: In a real implementation, we would need to:
+        // 1. Decode the base64 audio
+        // 2. Calculate the number of samples to keep based on audio_end_ms
+        // 3. Truncate the audio data
+        // 4. Re-encode to base64
+        // For now, we'll just remove the transcript to ensure no text is in context that hasn't been heard
+        delete contentPart.transcript;
+        
+        // In a full implementation, we would also truncate the audio data itself
+        logger.info({
+          sessionId: this.sessionKey,
+          itemId: event.item_id,
+          audioEndMs: event.audio_end_ms,
+          contentIndex: event.content_index,
+        }, `Truncating item ${event.item_id} at ${event.audio_end_ms}ms`);
+      }
+    }
+
+    // Send the truncated event
+    this.send(
+      RealtimeEventFactory.conversationItemTruncated(
+        event.item_id,
+        event.content_index,
+        event.audio_end_ms,
+      ),
+    );
+  }
+
+  /**
+   * Handle conversation.item.delete event
+   */
+  async deleteConversationItem(
+    event: RT.ConversationItemDeleteEvent,
+  ): Promise<void> {
+    const index = this.realtimeSession.conversationItems.findIndex(
+      (i) => i.id === event.item_id,
+    );
+
+    if (index === -1) {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          code: 'item_not_found',
+          message: `Item with id ${event.item_id} not found`,
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    // Remove the item from conversation history
+    this.realtimeSession.conversationItems.splice(index, 1);
+
+    // Also remove from connection.state.messages so the graph doesn't see it
+    const connection = this.inworldApp.connections[this.sessionKey];
+    if (connection?.state?.messages) {
+      const messageIndex = connection.state.messages.findIndex(
+        (m) => m.id === event.item_id,
+      );
+      if (messageIndex !== -1) {
+        connection.state.messages.splice(messageIndex, 1);
+      }
+    }
+
+    // Send the deleted event
+    this.send(
+      RealtimeEventFactory.conversationItemDeleted(event.item_id),
+    );
+  }
+
+  /**
+   * Handle conversation.item.retrieve event
+   */
+  async retrieveConversationItem(
+    event: RT.ConversationItemRetrieveEvent,
+  ): Promise<void> {
+    const item = this.realtimeSession.conversationItems.find(
+      (i) => i.id === event.item_id,
+    );
+
+    if (!item) {
+      this.send(
+        RealtimeEventFactory.error({
+          type: 'invalid_request_error',
+          code: 'item_not_found',
+          message: `Item with id ${event.item_id} not found`,
+          event_id: event.event_id,
+        }),
+      );
+      return;
+    }
+
+    // Send the retrieved item
+    this.send(
+      RealtimeEventFactory.conversationItemRetrieved(item),
+    );
+  }
+}
+
diff --git a/realtime-service/src/components/runtime_app_manager.ts b/realtime-service/src/components/runtime_app_manager.ts
new file mode 100644
index 0000000..341c76e
--- /dev/null
+++ b/realtime-service/src/components/runtime_app_manager.ts
@@ -0,0 +1,140 @@
+import { stopInworldRuntime } from '@inworld/runtime';
+import logger from '../logger';
+import { InworldApp } from './app';
+import { Connection } from '../types/index';
+
+export interface AppConfig {
+  graphId?: string;
+  llmModelName?: string;
+  llmProvider?: string;
+  voiceId?: string;
+  ttsModelId?: string;
+  graphVisualizationEnabled?: boolean;
+  assemblyAIApiKey?: string;
+  useMocks?: boolean;
+}
+
+export interface InworldAppConfig extends AppConfig {
+  sharedConnections?: { [sessionId: string]: Connection };
+}
+
+/**
+ * Helper to merge string config values with fallback chain
+ */
+function getStringConfig(
+  configValue: string | undefined,
+  defaultValue: string | undefined,
+  envVar?: string | undefined,
+  fallback: string = '',
+): string {
+  return configValue || defaultValue || envVar || fallback;
+}
+
+/**
+ * Helper to merge boolean config values with fallback chain
+ * Uses nullish coalescing to preserve false values
+ */
+function getBooleanConfig(
+  configValue: boolean | undefined,
+  defaultValue: boolean | undefined,
+  envVar: string | undefined,
+  fallback: boolean,
+): boolean {
+  if (configValue !== undefined) return configValue;
+  if (defaultValue !== undefined) return defaultValue;
+  if (envVar !== undefined && envVar.trim() !== '') {
+    return envVar.toLowerCase().trim() === 'true';
+  }
+  return fallback;
+}
+
+/**
+ * InworldRuntimeAppManager manages a single InworldApp instance.
+ * The graph supports multitenancy natively, so we only need one instance.
+ */
+export class InworldRuntimeAppManager {
+  private app: InworldApp | null = null;
+  private defaultConfig: Partial<AppConfig>;
+  private initPromise: Promise<InworldApp> | null = null;
+
+  // Shared connections map for all sessions
+  private sharedConnections: { [sessionId: string]: Connection } = {};
+
+  constructor(defaultConfig?: Partial<AppConfig>) {
+    this.defaultConfig = defaultConfig || {};
+  }
+
+  /**
+   * Get the singleton InworldApp instance, creating it if needed.
+   * Uses lazy initialization with proper handling of concurrent calls.
+   */
+  async getApp(configOverrides?: Partial<AppConfig>): Promise<InworldApp> {
+    // Return existing app if already initialized
+    if (this.app) {
+      return this.app;
+    }
+
+    // If initialization is in progress, wait for it
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    // Start initialization
+    this.initPromise = this.createApp(configOverrides);
+
+    try {
+      this.app = await this.initPromise;
+      return this.app;
+    } finally {
+      this.initPromise = null;
+    }
+  }
+
+  private async createApp(configOverrides?: Partial<AppConfig>): Promise<InworldApp> {
+    logger.info('Creating InworldApp instance');
+
+    const finalConfig: InworldAppConfig = {
+      graphId: getStringConfig(configOverrides?.graphId, this.defaultConfig.graphId, undefined),
+      llmModelName: getStringConfig(configOverrides?.llmModelName, this.defaultConfig.llmModelName),
+      llmProvider: getStringConfig(configOverrides?.llmProvider, this.defaultConfig.llmProvider),
+      voiceId: getStringConfig(configOverrides?.voiceId, this.defaultConfig.voiceId),
+      ttsModelId: getStringConfig(configOverrides?.ttsModelId, this.defaultConfig.ttsModelId),
+      graphVisualizationEnabled: getBooleanConfig(configOverrides?.graphVisualizationEnabled, this.defaultConfig.graphVisualizationEnabled, process.env.GRAPH_VISUALIZATION_ENABLED, false),
+      assemblyAIApiKey: getStringConfig(configOverrides?.assemblyAIApiKey, this.defaultConfig.assemblyAIApiKey, process.env.ASSEMBLYAI_API_KEY),
+      useMocks: getBooleanConfig(configOverrides?.useMocks, this.defaultConfig.useMocks, process.env.USE_MOCKS, false),
+      sharedConnections: this.sharedConnections,
+    };
+
+    // Validate required config
+    if (!finalConfig.assemblyAIApiKey) {
+      const error = new Error('Missing AssemblyAI API key');
+      logger.error({ err: error }, 'Missing AssemblyAI API key');
+      throw error;
+    }
+
+    const app = await InworldApp.create(finalConfig);
+    logger.info('InworldApp initialized successfully');
+    return app;
+  }
+
+  /**
+   * Check if the app has been initialized
+   */
+  isInitialized(): boolean {
+    return this.app !== null;
+  }
+
+  /**
+   * Shutdown the app and clean up resources
+   */
+  async shutdown(): Promise<void> {
+    if (this.app) {
+      logger.info('Shutting down InworldApp');
+      await this.app.shutdown();
+      this.app = null;
+    }
+
+    // Stop the global Inworld runtime
+    stopInworldRuntime();
+  }
+}
diff --git a/realtime-service/src/config.ts b/realtime-service/src/config.ts
new file mode 100644
index 0000000..7bbba6f
--- /dev/null
+++ b/realtime-service/src/config.ts
@@ -0,0 +1,15 @@
+// Audio Configuration Constants
+export const TTS_SAMPLE_RATE = 24000; // Sample rate for TTS output
+export const INPUT_SAMPLE_RATE = 16000; // Sample rate for STT input (Assembly.AI)
+
+// Server Configuration
+export const WS_APP_PORT = 4000; // WebSocket server port
+
+// LLM Model Configuration
+export const DEFAULT_LLM_MODEL_NAME = process.env.LLM_MODEL_NAME || 'meta-llama/Llama-3.1-70b-Instruct';
+export const DEFAULT_LLM_PROVIDER = process.env.LLM_PROVIDER || 'inworld';
+
+// Voice and TTS Configuration
+export const DEFAULT_VOICE_ID = process.env.VOICE_ID || 'Dennis';
+export const DEFAULT_TTS_MODEL_ID = process.env.TTS_MODEL_ID || 'inworld-tts-1';
+
diff --git a/realtime-service/src/helpers.ts b/realtime-service/src/helpers.ts
new file mode 100644
index 0000000..855febb
--- /dev/null
+++ b/realtime-service/src/helpers.ts
@@ -0,0 +1,65 @@
+import logger from './logger';
+import { DEFAULT_LLM_MODEL_NAME, DEFAULT_LLM_PROVIDER, DEFAULT_VOICE_ID, DEFAULT_TTS_MODEL_ID } from './config';
+
+export const parseEnvironmentVariables = () => {
+  if (!process.env.INWORLD_API_KEY) {
+    throw new Error('INWORLD_API_KEY env variable is required');
+  }
+
+  // Assembly.AI is now the only STT provider for audio input
+  if (!process.env.ASSEMBLYAI_API_KEY) {
+    throw new Error('ASSEMBLYAI_API_KEY env variable is required');
+  }
+
+  logger.info('STT Service: Assembly.AI (only supported provider)');
+
+  return {
+    apiKey: process.env.INWORLD_API_KEY,
+    llmModelName: DEFAULT_LLM_MODEL_NAME,
+    llmProvider: DEFAULT_LLM_PROVIDER,
+    voiceId: DEFAULT_VOICE_ID,
+    ttsModelId: DEFAULT_TTS_MODEL_ID,
+    // Because the env variable is optional and it's a string, we need to convert it to a boolean safely
+    graphVisualizationEnabled:
+      (process.env.GRAPH_VISUALIZATION_ENABLED || '').toLowerCase().trim() ===
+      'true',
+    assemblyAIApiKey: process.env.ASSEMBLYAI_API_KEY,
+    appName: process.env.APP_NAME || 'realtime-service',
+    appVersion: process.env.APP_VERSION || '1.0.0',
+  };
+};
+
+/**
+ * Safely aborts a stream with proper error handling and logging.
+ * Handles both regular streams with abort() method and ContentStreams with napiStream.
+ * 
+ * @param stream The stream to abort (must have an abort method or napiStream with abort method)
+ * @param streamName Descriptive name for the stream (for logging)
+ * @param sessionId Session ID associated with the stream (for logging)
+ * @param context Optional context message for logging (e.g., 'on close', 'due to cancellation')
+ */
+export function abortStream(
+  stream: any | undefined,
+  streamName: string,
+  sessionId: string,
+  context: string = ''
+): void {
+  if (!stream) {
+    return;
+  }
+
+  const logContext = context ? ` ${context}` : '';
+  logger.debug({ sessionId }, `Aborting ${streamName}${logContext}`);
+
+  try {
+    if (typeof stream.abort === 'function') {
+      stream.abort();
+    } else if (stream.napiStream && typeof stream.napiStream.abort === 'function') {
+      // ContentStream doesn't have an abort() method, but we can try to abort the underlying napiStream
+      stream.napiStream.abort();
+    }
+  } catch (error) {
+    logger.error({ error, sessionId }, `Error aborting ${streamName}`);
+  }
+}
+
diff --git a/realtime-service/src/index.ts b/realtime-service/src/index.ts
new file mode 100644
index 0000000..55d24bc
--- /dev/null
+++ b/realtime-service/src/index.ts
@@ -0,0 +1,319 @@
+import 'dotenv/config';
+
+import {InworldError} from '@inworld/runtime/common';
+import {initTelemetry} from '@inworld/runtime/telemetry';
+import cors from 'cors';
+import express from 'express';
+import http from 'http';
+import {createServer} from 'http';
+import client from 'prom-client';
+import {parse} from 'url';
+import {RawData, WebSocketServer} from 'ws';
+
+import {RealtimeMessageHandler} from './components/realtime/realtime_message_handler';
+import {InworldRuntimeAppManager} from './components/runtime_app_manager';
+import {WS_APP_PORT} from './config';
+import {abortStream, parseEnvironmentVariables} from './helpers';
+import {formatContext, formatError, formatSession, formatWorkspace} from './log-helpers';
+import logger from './logger';
+
+const METRICS_PORT = 9000;
+const register = new client.Registry();
+register.setDefaultLabels({app: 'realtime-service'});
+
+// Enable collection of default metrics
+client.collectDefaultMetrics({register});
+
+const wsConnectionCounter = new client.Gauge({
+  name: 'websocket_connections_total',
+  help: 'Total number of active WebSocket connections',
+  registers: [register],
+});
+
+const app = express();
+const server = createServer(app);
+const webSocket = new WebSocketServer({noServer: true});
+
+const metricsApp = express();
+const metricsServer = http.createServer(metricsApp);
+
+app.use(cors());
+app.use(express.json());
+app.use(express.static('frontend'));
+
+// InworldRuntimeAppManager manages a single graph instance
+// The graph supports multitenancy natively via API key in execute method
+const env = parseEnvironmentVariables();
+const inworldRuntimeAppManager = new InworldRuntimeAppManager({
+  llmModelName: env.llmModelName,
+  llmProvider: env.llmProvider,
+  voiceId: env.voiceId,
+  ttsModelId: env.ttsModelId,
+  graphVisualizationEnabled: env.graphVisualizationEnabled,
+  assemblyAIApiKey: env.assemblyAIApiKey,
+});
+
+initTelemetry({
+  apiKey: env.apiKey,
+  appName: env.appName,
+  appVersion: env.appVersion,
+});
+
+metricsApp.get('/metrics', async (req, res) => {
+  try {
+    res.set('Content-Type', register.contentType);
+    res.end(await register.metrics());
+  } catch (ex) {
+    logger.error({error: ex}, `Error serving metrics${formatError(ex)}`);
+    res.status(500).end('Internal Server Error');
+  }
+});
+
+app.get('/health', (req, res) => {
+  res.status(200).send('OK');
+});
+
+/**
+ * Extracts the Inworld API key from the WebSocket protocol header.
+ * The key is embedded in the sec-websocket-protocol header with a 'basic_'
+ * prefix. This function removes the prefix and reconstructs any missing base64
+ * padding.
+ */
+function extractInworldApiKey(headers: http.IncomingHttpHeaders): string|
+    undefined {
+  const wsProtocolHeader = headers['sec-websocket-protocol'] as string;
+  if (!wsProtocolHeader) {
+    return undefined;
+  }
+
+  // The protocol header may contain comma-separated values, look for basic_
+  // prefix
+  const protocols = wsProtocolHeader.split(',').map(p => p.trim());
+  for (const protocol of protocols) {
+    if (protocol.startsWith('basic_')) {
+      let base64Key = protocol.substring(
+          6);  // Remove 'basic_' prefix to get base64 credentials
+
+      // Reconstruct missing padding = symbols (sender cuts trailing = symbols)
+      // Base64 strings should be a multiple of 4 characters in length
+      const paddingNeeded = (4 - (base64Key.length % 4)) % 4;
+      if (paddingNeeded > 0) {
+        base64Key += '='.repeat(paddingNeeded);
+      }
+      return base64Key;
+    }
+  }
+
+  return undefined;
+}
+
+webSocket.on('connection', async (ws, request) => {
+  wsConnectionCounter.inc(1);
+  const workspaceId = (request.headers['workspace-id'] as string) ||
+      process.env.WORKSPACE_ID || 'default';
+
+  try {
+    logger.info(
+        {workspaceId},
+        `WebSocket connection received ${formatWorkspace(workspaceId)}`);
+
+    // Extract the Inworld API key from sec-websocket-protocol header
+    const inworldApiKey = extractInworldApiKey(request.headers);
+
+    const {query} = parse(request.url!, true);
+    const sessionId = query.key?.toString();
+
+    logger.info(
+        {sessionId, workspaceId},
+        `WebSocket connection established ${
+            formatContext(sessionId, workspaceId)}`);
+
+    if (!sessionId) {
+      logger.error(
+          {workspaceId},
+          `WebSocket connection rejected ${
+              formatWorkspace(workspaceId)}: no session key provided`);
+      ws.close(1008, 'No session key provided');
+      return;
+    }
+
+    // Get the singleton InworldApp instance
+    const inworldApp = await inworldRuntimeAppManager.getApp();
+
+    // Create session on-the-fly if it doesn't exist
+    if (!inworldApp.connections?.[sessionId]) {
+      logger.info(
+          {sessionId, workspaceId},
+          `Creating new session ${formatContext(sessionId, workspaceId)}`);
+      // Create a minimal connection for realtime protocol
+      // The session will be fully configured via session.update events
+      inworldApp.connections[sessionId] = {
+        workspaceId,
+        state: {
+          interactionId: '',  // Will be set by graph nodes
+          messages: [],
+          agent: null,
+          userName: 'User',
+        },
+        apiKey: inworldApiKey || '',
+        ws: null,
+      };
+    }
+
+    inworldApp.connections[sessionId].ws =
+        inworldApp.connections[sessionId].ws ?? ws;
+
+    ws.on('error', (error) => {
+      logger.error(
+          {error, sessionId, workspaceId},
+          `WebSocket error ${formatContext(sessionId, workspaceId)}${
+              formatError(error)}`);
+    });
+
+    ws.on('close', async (code, reason) => {
+      logger.info(
+          {sessionId, workspaceId, code, reason: reason.toString()},
+          `WebSocket closed ${formatContext(sessionId, workspaceId)} [code:${
+              code}] [reason:${reason.toString()}]`);
+      wsConnectionCounter.dec(1);
+
+      const connection = inworldApp.connections[sessionId];
+      if (connection) {
+        // Step 1: Abort any active graph executions FIRST
+        abortStream(
+            connection.currentAudioExecutionStream, 'audio execution stream',
+            sessionId, 'on close');
+        connection.currentAudioExecutionStream = undefined;
+
+        // Step 2: Clean up multimodal stream if it exists
+        if (connection.multimodalStreamManager) {
+          logger.info(
+              {sessionId},
+              `Ending multimodal stream ${
+                  formatSession(sessionId)} due to WebSocket close`);
+          connection.multimodalStreamManager.end();
+          connection.multimodalStreamManager = undefined;
+        }
+
+        // Step 3: Clean up audio graph execution reference
+        if (connection.currentAudioGraphExecution) {
+          connection.currentAudioGraphExecution = undefined;
+        }
+      }
+
+      // Clean up AssemblyAI STT session if it exists
+      const assemblyAINode = inworldApp.graphWithAudioInput?.assemblyAINode;
+      if (assemblyAINode) {
+        try {
+          await assemblyAINode.closeSession(sessionId);
+        } catch (error) {
+          logger.error(
+              {error, sessionId, workspaceId},
+              `Error during closing Assembly Session ${
+                  formatContext(sessionId, workspaceId)}${formatError(error)}`);
+        }
+      }
+
+      // Clean up connection
+      inworldApp.removeSession(sessionId);
+      logger.info(`[Session ${sessionId}] Session removed and resources cleaned up`);
+    });
+
+    // Use OpenAI Realtime API protocol
+    const realtimeHandler = new RealtimeMessageHandler(
+        inworldApp,
+        sessionId,
+        (data: any) => ws.send(JSON.stringify(data)),
+    );
+
+    // Initialize session and send session.created event
+    logger.info(
+        {sessionId, workspaceId},
+        `Initializing realtime session ${
+            formatContext(sessionId, workspaceId)}`);
+    await realtimeHandler.initialize();
+    logger.info(
+        {sessionId, workspaceId},
+        `Realtime session initialized successfully ${
+            formatContext(sessionId, workspaceId)}`);
+
+    ws.on('message', (data: RawData) => realtimeHandler.handleMessage(data));
+  } catch (error) {
+    logger.error(
+        {error, workspaceId},
+        `WebSocket connection error ${formatWorkspace(workspaceId)}${
+            formatError(error)}`);
+    ws.close(1011, 'Internal server error');
+  }
+});
+
+server.on('upgrade', async (request, socket, head) => {
+  const {pathname, query} = parse(request.url!, true);
+
+  if (pathname === '/session') {
+    const authToken = process.env.AUTH_TOKEN;
+
+    // Validate token if configured
+    if (authToken) {
+      const providedToken = query?.token?.toString();
+
+      if (!providedToken || providedToken !== authToken) {
+        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+    }
+
+    webSocket.handleUpgrade(request, socket, head, (ws) => {
+      webSocket.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(WS_APP_PORT, () => {
+  logger.info(
+      {port: WS_APP_PORT},
+      `Application Server listening on port ${WS_APP_PORT}`);
+  logger.info('InworldApp will be created on first connection');
+});
+
+metricsServer.listen(METRICS_PORT, () => {
+  logger.info(
+      {port: METRICS_PORT}, `Metrics Server listening on port ${METRICS_PORT}`);
+});
+
+function done() {
+  logger.info('Server is closing');
+
+  // Handle the async shutdown properly
+  inworldRuntimeAppManager.shutdown()
+      .then(() => {
+        metricsServer.close(() => {
+          logger.info('Metrics server closed');
+          process.exit(0);
+        });
+      })
+      .catch((err) => {
+        logger.error({error: err}, `Error during shutdown${formatError(err)}`);
+        process.exit(1);
+      });
+}
+
+process.on('SIGINT', done);
+process.on('SIGTERM', done);
+process.on('SIGUSR2', done);
+process.on('unhandledRejection', (err: unknown) => {
+  if (err instanceof InworldError) {
+    logger.error(
+        {
+          message: err.message,
+          context: err.context,
+        },
+        `Inworld Error - unhandled rejection${formatError(err)}`);
+  } else {
+    logger.error({error: err}, `Unhandled rejection${formatError(err)}`);
+  }
+  process.exit(1);
+});
diff --git a/realtime-service/src/log-helpers.ts b/realtime-service/src/log-helpers.ts
new file mode 100644
index 0000000..074f8d9
--- /dev/null
+++ b/realtime-service/src/log-helpers.ts
@@ -0,0 +1,88 @@
+/**
+ * Helper utilities for creating readable log messages with key context
+ * 
+ * These helpers make it easy to include important information in both:
+ * 1. The message text (visible at a glance)
+ * 2. Structured fields (for querying/filtering)
+ */
+
+/**
+ * Format a session context tag for log messages
+ * Usage: `Something happened ${formatSession(sessionId)}`
+ */
+export function formatSession(sessionId: string | undefined): string {
+  return sessionId ? `[session:${sessionId}]` : '';
+}
+
+/**
+ * Format a workspace context tag for log messages
+ * Usage: `Something happened ${formatWorkspace(workspaceId)}`
+ */
+export function formatWorkspace(workspaceId: string | undefined): string {
+  return workspaceId ? `[workspace:${workspaceId}]` : '';
+}
+
+/**
+ * Format an interaction context tag for log messages
+ * Usage: `Something happened ${formatInteraction(interactionId)}`
+ */
+export function formatInteraction(interactionId: string | undefined): string {
+  return interactionId ? `[interaction:${interactionId}]` : '';
+}
+
+/**
+ * Format a duration in milliseconds
+ * Usage: `Completed ${formatDuration(elapsed)}`
+ */
+export function formatDuration(ms: number | undefined): string {
+  return ms !== undefined ? `[duration:${ms}ms]` : '';
+}
+
+/**
+ * Format an error message
+ * Usage: `Failed ${formatError(error)}`
+ */
+export function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return `: ${error.message}`;
+  }
+  return error ? `: ${String(error)}` : '';
+}
+
+/**
+ * Combine session and workspace tags
+ * Usage: `Something happened ${formatContext(sessionId, workspaceId)}`
+ */
+export function formatContext(
+  sessionId?: string,
+  workspaceId?: string,
+  interactionId?: string
+): string {
+  const parts = [
+    formatSession(sessionId),
+    formatWorkspace(workspaceId),
+    formatInteraction(interactionId),
+  ].filter(Boolean);
+  
+  return parts.join(' ');
+}
+
+/**
+ * Example usage:
+ * 
+ * logger.info(
+ *   { sessionId, workspaceId },
+ *   `WebSocket connected ${formatContext(sessionId, workspaceId)}`
+ * );
+ * 
+ * logger.error(
+ *   { error, sessionId, operation },
+ *   `Operation failed ${formatSession(sessionId)}${formatError(error)}`
+ * );
+ * 
+ * logger.info(
+ *   { sessionId, duration },
+ *   `Request completed ${formatSession(sessionId)} ${formatDuration(duration)}`
+ * );
+ */
+
diff --git a/realtime-service/src/logger.ts b/realtime-service/src/logger.ts
new file mode 100644
index 0000000..7d20f50
--- /dev/null
+++ b/realtime-service/src/logger.ts
@@ -0,0 +1,66 @@
+import pino from 'pino';
+
+/**
+ * Logger configuration for Google Cloud Logging compatibility
+ * 
+ * DEFAULT: JSON logs formatted for Cloud Logging (production-ready)
+ * OPTIONAL: Pretty-print for local development
+ * 
+ * Each log entry is a single JSON object, preventing multi-line splits in Cloud Logging
+ * 
+ * Environment variables:
+ * - REALTIME_LOG_LEVEL: 'debug', 'info', 'warn', 'error' (default: 'info')
+ * - REALTIME_LOG_PRETTY: '1' to enable pretty logs locally (default: '0' = JSON)
+ * 
+ * Examples:
+ *   npm start                              # JSON logs (default, cloud-ready)
+ *   REALTIME_LOG_PRETTY=1 npm start        # Pretty logs (local dev)
+ *   REALTIME_LOG_LEVEL=debug npm start     # JSON with debug level
+ */
+const usePretty = process.env.REALTIME_LOG_PRETTY === '1';
+
+const logger = pino({
+  level: process.env.REALTIME_LOG_LEVEL || 'info',
+
+  // Use pretty print locally (unless LOG_PRETTY=0), JSON in production
+  transport: usePretty ? {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      translateTime: 'HH:MM:ss.l', // Include milliseconds for debugging
+      ignore: 'pid,hostname,service,version',
+      // Show message and structured fields in a compact format
+      messageFormat: '{levelLabel} {msg}',
+      // Show structured fields in compact single-line format
+      singleLine: true,
+      // Limit object depth to avoid huge logs
+      depth: 3,
+    }
+  } : undefined,
+
+  // Add common fields to all logs
+  base: {
+    service: 'realtime-service',
+    version: process.env.APP_VERSION || 'unknown',
+  },
+
+  // Format timestamps for Cloud Logging
+  timestamp: pino.stdTimeFunctions.isoTime,
+
+  // Map Pino levels to Cloud Logging severity
+  formatters: {
+    level: (label: string) => {
+      return { severity: label.toUpperCase() };
+    },
+  },
+
+  // Serialize errors properly
+  serializers: {
+    error: pino.stdSerializers.err,
+    req: pino.stdSerializers.req,
+    res: pino.stdSerializers.res,
+  },
+});
+
+export default logger;
+
diff --git a/realtime-service/src/package-lock.json b/realtime-service/src/package-lock.json
new file mode 100644
index 0000000..3d3144e
--- /dev/null
+++ b/realtime-service/src/package-lock.json
@@ -0,0 +1,3273 @@
+{
+  "name": "server",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "server",
+      "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
+      "dependencies": {
+        "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.7",
+        "express": "^5.1.0",
+        "express-validator": "^7.2.1",
+        "groq-sdk": "^0.7.0",
+        "pino": "^9.14.0",
+        "pino-pretty": "^13.1.2",
+        "prom-client": "^15.1.3",
+        "uuid": "^11.1.0",
+        "wav-encoder": "^1.3.0",
+        "ws": "^8.18.1",
+        "zod": "^4.1.13"
+      },
+      "devDependencies": {
+        "@types/cors": "^2.8.17",
+        "@types/express": "^5.0.1",
+        "@types/express-validator": "^3.0.0",
+        "@types/node": "^22.14.0",
+        "@types/ws": "^8.18.1",
+        "nodemon": "^3.1.9",
+        "ts-node": "^10.9.2",
+        "tsconfig-paths": "^4.2.0",
+        "typescript": "^5.8.3"
+      }
+    },
+    "node_modules/@cspotcode/source-map-support": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "0.3.9"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@inworld/runtime": {
+      "version": "0.9.0-rc.13",
+      "resolved": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+      "integrity": "sha512-6C/aND5PqOVzujwoS0rvUR963VxJ+MO0X+IZg9WpjrxBbuFag7fXay5yyamH0cKoTvmaTT2s8fca8pK0zQ0CYg==",
+      "hasInstallScript": true,
+      "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
+      "dependencies": {
+        "@types/lodash.snakecase": "^4.1.9",
+        "@types/protobufjs": "^6.0.0",
+        "@zod/core": "^0.11.6",
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
+        "assemblyai": "^4.17.0",
+        "chalk": "^4.1.2",
+        "decompress": "^4.2.1",
+        "decompress-targz": "^4.1.1",
+        "decompress-unzip": "^4.0.1",
+        "groq-sdk": "^0.33.0",
+        "lodash.snakecase": "^4.1.1",
+        "node-record-lpcm16": "^1.0.1",
+        "protobufjs": "^7.5.4",
+        "uuid": "^11.1.0",
+        "zod-to-json-schema": "^3.25.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@inworld/runtime/node_modules/@types/node": {
+      "version": "18.19.130",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
+      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/@inworld/runtime/node_modules/groq-sdk": {
+      "version": "0.33.0",
+      "resolved": "https://registry.npmjs.org/groq-sdk/-/groq-sdk-0.33.0.tgz",
+      "integrity": "sha512-wb7NrBq7LZDDhDPSpuAd9LpZ0MNjmWKGLfybYfjY3r63mSpfiP8+GQZQcSDJcX+jIMzSm+SwzxModDyVZ2T66Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/node": "^18.11.18",
+        "@types/node-fetch": "^2.6.4",
+        "abort-controller": "^3.0.0",
+        "agentkeepalive": "^4.2.1",
+        "form-data-encoder": "1.7.2",
+        "formdata-node": "^4.3.2",
+        "node-fetch": "^2.6.7"
+      }
+    },
+    "node_modules/@inworld/runtime/node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
+    "node_modules/@opentelemetry/api": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
+      "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/@pinojs/redact": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz",
+      "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
+      "license": "MIT"
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@tsconfig/node10": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.12.tgz",
+      "integrity": "sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node12": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
+      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node14": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
+      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node16": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
+      "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.6",
+      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/express": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.6.tgz",
+      "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^5.0.0",
+        "@types/serve-static": "^2"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.1.0.tgz",
+      "integrity": "sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/express-validator": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/express-validator/-/express-validator-3.0.2.tgz",
+      "integrity": "sha512-dV+1u6absDDEIVe5jd5ID1XYvPPvOSvggMWh09VYM3TeBjAjBDtwJWyJg/5PnK7s8FRgbOtHgD6oX3N2MKWwDw==",
+      "deprecated": "This is a stub types definition. express-validator provides its own type definitions, so you do not need this installed.",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "express-validator": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-FOvQ0YPD5NOfPgMzJihoT+Za5pdkDJWcbpuj1DjaKZIr/gxodQjY/uWEFlTNqW2ugXHUiL8lRQgw63dzKHZdeQ==",
+      "license": "MIT"
+    },
+    "node_modules/@types/lodash.snakecase": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@types/lodash.snakecase/-/lodash.snakecase-4.1.9.tgz",
+      "integrity": "sha512-emBZJUiNlo+QPXr1junMKXwzHJK9zbFvTVdyAoorFcm1YRsbzkZCYPTVMM9AW+dlnA6utG7vpfvOs8alxv/TMw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/lodash": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.2.tgz",
+      "integrity": "sha512-LPM2G3Syo1GLzXLGJAKdqoU35XvrWzGJ21/7sgZTUpbkBaOasTj8tjwn6w+hCkqaa1TfJ/w67rJSwYItlJ2mYw==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/node-fetch": {
+      "version": "2.6.13",
+      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz",
+      "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "form-data": "^4.0.4"
+      }
+    },
+    "node_modules/@types/protobufjs": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@types/protobufjs/-/protobufjs-6.0.0.tgz",
+      "integrity": "sha512-A27RDExpAf3rdDjIrHKiJK6x8kqqJ4CmoChwtipfhVAn1p7+wviQFFP7dppn8FslSbHtQeVPvi8wNKkDjSYjHw==",
+      "deprecated": "This is a stub types definition for protobufjs (https://github.com/dcodeIO/ProtoBuf.js). protobufjs provides its own type definitions, so you don't need @types/protobufjs installed!",
+      "license": "MIT",
+      "dependencies": {
+        "protobufjs": "*"
+      }
+    },
+    "node_modules/@types/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
+      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-errors": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@zod/core": {
+      "version": "0.11.6",
+      "resolved": "https://registry.npmjs.org/@zod/core/-/core-0.11.6.tgz",
+      "integrity": "sha512-03Bv82fFSfjDAvMfdHHdGSS6SOJs0iCcJlWJv1kJHRtoTT02hZpyip/2Lk6oo4l4FtjuwTrsEQTwg/LD8I7dJA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.4",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "acorn": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/agentkeepalive": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz",
+      "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "humanize-ms": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/arg": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
+      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/assemblyai": {
+      "version": "4.21.0",
+      "resolved": "https://registry.npmjs.org/assemblyai/-/assemblyai-4.21.0.tgz",
+      "integrity": "sha512-Nbbtk3wwHB1vhi7+98kYi/e9N9EFY0wAv5OuKXNmGw9eHkHG2r3ytgYOigcXyzC8cCvQdhA8Y0JCQm2BFDOOlQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ws": "^8.18.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/atomic-sleep": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz",
+      "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/available-typed-arrays": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "possible-typed-array-names": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/bintrees": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bintrees/-/bintrees-1.0.2.tgz",
+      "integrity": "sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==",
+      "license": "MIT"
+    },
+    "node_modules/bl": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/bl/-/bl-1.2.3.tgz",
+      "integrity": "sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==",
+      "license": "MIT",
+      "dependencies": {
+        "readable-stream": "^2.3.5",
+        "safe-buffer": "^5.1.1"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.1.tgz",
+      "integrity": "sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.3",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.7.0",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.1",
+        "type-is": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
+    "node_modules/buffer-alloc": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz",
+      "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-alloc-unsafe": "^1.1.0",
+        "buffer-fill": "^1.0.0"
+      }
+    },
+    "node_modules/buffer-alloc-unsafe": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz",
+      "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==",
+      "license": "MIT"
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/buffer-fill": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz",
+      "integrity": "sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==",
+      "license": "MIT"
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.0",
+        "es-define-property": "^1.0.0",
+        "get-intrinsic": "^1.2.4",
+        "set-function-length": "^1.2.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/colorette": {
+      "version": "2.0.20",
+      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
+      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
+      "license": "MIT"
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/content-disposition": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz",
+      "integrity": "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/create-require": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
+      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/dateformat": {
+      "version": "4.6.3",
+      "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-4.6.3.tgz",
+      "integrity": "sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decompress": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/decompress/-/decompress-4.2.1.tgz",
+      "integrity": "sha512-e48kc2IjU+2Zw8cTb6VZcJQ3lgVbS4uuB1TfCHbiZIP/haNXm+SVyhu+87jts5/3ROpd82GSVCoNs/z8l4ZOaQ==",
+      "license": "MIT",
+      "dependencies": {
+        "decompress-tar": "^4.0.0",
+        "decompress-tarbz2": "^4.0.0",
+        "decompress-targz": "^4.0.0",
+        "decompress-unzip": "^4.0.1",
+        "graceful-fs": "^4.1.10",
+        "make-dir": "^1.0.0",
+        "pify": "^2.3.0",
+        "strip-dirs": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-tar": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/decompress-tar/-/decompress-tar-4.1.1.tgz",
+      "integrity": "sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==",
+      "license": "MIT",
+      "dependencies": {
+        "file-type": "^5.2.0",
+        "is-stream": "^1.1.0",
+        "tar-stream": "^1.5.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-tarbz2": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz",
+      "integrity": "sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==",
+      "license": "MIT",
+      "dependencies": {
+        "decompress-tar": "^4.1.0",
+        "file-type": "^6.1.0",
+        "is-stream": "^1.1.0",
+        "seek-bzip": "^1.0.5",
+        "unbzip2-stream": "^1.0.9"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-tarbz2/node_modules/file-type": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/file-type/-/file-type-6.2.0.tgz",
+      "integrity": "sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-targz": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/decompress-targz/-/decompress-targz-4.1.1.tgz",
+      "integrity": "sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==",
+      "license": "MIT",
+      "dependencies": {
+        "decompress-tar": "^4.1.1",
+        "file-type": "^5.2.0",
+        "is-stream": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-unzip": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/decompress-unzip/-/decompress-unzip-4.0.1.tgz",
+      "integrity": "sha512-1fqeluvxgnn86MOh66u8FjbtJpAFv5wgCT9Iw8rcBqQcCo5tO8eiJw7NNTrvt9n4CRBVq7CstiS922oPgyGLrw==",
+      "license": "MIT",
+      "dependencies": {
+        "file-type": "^3.8.0",
+        "get-stream": "^2.2.0",
+        "pify": "^2.3.0",
+        "yauzl": "^2.4.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/decompress-unzip/node_modules/file-type": {
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz",
+      "integrity": "sha512-RLoqTXE8/vPmMuTI88DAzhMYC99I8BWv7zYP4A1puo5HIjEJ5EX48ighy4ZyKMG9EDXxBgW6e++cn7d1xuFghA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/diff": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
+      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/event-target-shim": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
+      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.1",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-validator": {
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/express-validator/-/express-validator-7.3.1.tgz",
+      "integrity": "sha512-IGenaSf+DnWc69lKuqlRE9/i/2t5/16VpH5bXoqdxWz1aCpRvEdrBuu1y95i/iL5QP8ZYVATiwLFhwk3EDl5vg==",
+      "license": "MIT",
+      "dependencies": {
+        "lodash": "^4.17.21",
+        "validator": "~13.15.23"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      }
+    },
+    "node_modules/fast-copy": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/fast-copy/-/fast-copy-4.0.1.tgz",
+      "integrity": "sha512-+uUOQlhsaswsizHFmEFAQhB3lSiQ+lisxl50N6ZP0wywlZeWsIESxSi9ftPEps8UGfiBzyYP7x27zA674WUvXw==",
+      "license": "MIT"
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-safe-stringify": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
+      "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
+      "license": "MIT"
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
+      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/file-type": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/file-type/-/file-type-5.2.0.tgz",
+      "integrity": "sha512-Iq1nJ6D2+yIO4c8HHg4fyVb8mAJieo1Oloy1mLLaB2PvezNedhBVm+QU7g0qM42aiMbRXTxKKwGD17rjKNJYVQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
+      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/for-each": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+      "license": "MIT",
+      "dependencies": {
+        "is-callable": "^1.2.7"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/form-data-encoder": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz",
+      "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==",
+      "license": "MIT"
+    },
+    "node_modules/form-data/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/form-data/node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/formdata-node": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz",
+      "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "1.0.0",
+        "web-streams-polyfill": "4.0.0-beta.3"
+      },
+      "engines": {
+        "node": ">= 12.20"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/fs-constants": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
+      "license": "MIT"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-2.3.1.tgz",
+      "integrity": "sha512-AUGhbbemXxrZJRD5cDvKtQxLuYaIbNtDTK8YqupCI393Q2KSTreEsLUN3ZxAWFGiKTzL6nKuzfcIvieflUX9qA==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4.0.1",
+        "pinkie-promise": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
+    },
+    "node_modules/groq-sdk": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/groq-sdk/-/groq-sdk-0.7.0.tgz",
+      "integrity": "sha512-OgPqrRtti5MjEVclR8sgBHrhSkTLdFCmi47yrEF29uJZaiCkX3s7bXpnMhq8Lwoe1f4AwgC0qGOeHXpeSgu5lg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/node": "^18.11.18",
+        "@types/node-fetch": "^2.6.4",
+        "abort-controller": "^3.0.0",
+        "agentkeepalive": "^4.2.1",
+        "form-data-encoder": "1.7.2",
+        "formdata-node": "^4.3.2",
+        "node-fetch": "^2.6.7"
+      }
+    },
+    "node_modules/groq-sdk/node_modules/@types/node": {
+      "version": "18.19.130",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
+      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/groq-sdk/node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/help-me": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/help-me/-/help-me-5.0.0.tgz",
+      "integrity": "sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==",
+      "license": "MIT"
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/humanize-ms": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
+      "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.0.0"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.1.tgz",
+      "integrity": "sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-callable": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-natural-number": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-natural-number/-/is-natural-number-4.0.1.tgz",
+      "integrity": "sha512-Y4LTamMe0DDQIIAlaer9eKebAlDSV6huy+TWhJVPlzZh2o4tRP5SQWFlLn5N0To4mDD22/qdOq+veo1cSISLgQ==",
+      "license": "MIT"
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
+    "node_modules/is-stream": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
+      "integrity": "sha512-uQPm8kcs47jx38atAcWTVxyltQYoPT68y9aWYdV6yWXSyW8mzSat0TL6CiWdZeCdF3KrAvpVtnHbTv4RN+rqdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-typed-array": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/joycon": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
+      "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.snakecase": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz",
+      "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==",
+      "license": "MIT"
+    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/make-dir": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz",
+      "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pify": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/make-dir/node_modules/pify": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
+      "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/make-error": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
+      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/node-record-lpcm16": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/node-record-lpcm16/-/node-record-lpcm16-1.0.1.tgz",
+      "integrity": "sha512-H75GMOP8ErnF67m21+qSgj4USnzv5RLfm7OkEItdIi+soNKoJZpMQPX6umM8Cn9nVPSgd/dBUtc1msst5MmABA==",
+      "license": "ISC",
+      "dependencies": {
+        "debug": "^2.6.8"
+      }
+    },
+    "node_modules/node-record-lpcm16/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/node-record-lpcm16/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.11",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.11.tgz",
+      "integrity": "sha512-is96t8F/1//UHAjNPHpbsNY46ELPpftGUoSVNXwUfMk/qdjSylYrWSu1XavVTBOn526kFiOR733ATgNBCQyH0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/nodemon/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-exit-leak-free": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
+      "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz",
+      "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "license": "MIT"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/pinkie": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz",
+      "integrity": "sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/pinkie-promise": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz",
+      "integrity": "sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==",
+      "license": "MIT",
+      "dependencies": {
+        "pinkie": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/pino": {
+      "version": "9.14.0",
+      "resolved": "https://registry.npmjs.org/pino/-/pino-9.14.0.tgz",
+      "integrity": "sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==",
+      "license": "MIT",
+      "dependencies": {
+        "@pinojs/redact": "^0.4.0",
+        "atomic-sleep": "^1.0.0",
+        "on-exit-leak-free": "^2.1.0",
+        "pino-abstract-transport": "^2.0.0",
+        "pino-std-serializers": "^7.0.0",
+        "process-warning": "^5.0.0",
+        "quick-format-unescaped": "^4.0.3",
+        "real-require": "^0.2.0",
+        "safe-stable-stringify": "^2.3.1",
+        "sonic-boom": "^4.0.1",
+        "thread-stream": "^3.0.0"
+      },
+      "bin": {
+        "pino": "bin.js"
+      }
+    },
+    "node_modules/pino-abstract-transport": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz",
+      "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.0.0"
+      }
+    },
+    "node_modules/pino-pretty": {
+      "version": "13.1.3",
+      "resolved": "https://registry.npmjs.org/pino-pretty/-/pino-pretty-13.1.3.tgz",
+      "integrity": "sha512-ttXRkkOz6WWC95KeY9+xxWL6AtImwbyMHrL1mSwqwW9u+vLp/WIElvHvCSDg0xO/Dzrggz1zv3rN5ovTRVowKg==",
+      "license": "MIT",
+      "dependencies": {
+        "colorette": "^2.0.7",
+        "dateformat": "^4.6.3",
+        "fast-copy": "^4.0.0",
+        "fast-safe-stringify": "^2.1.1",
+        "help-me": "^5.0.0",
+        "joycon": "^3.1.1",
+        "minimist": "^1.2.6",
+        "on-exit-leak-free": "^2.1.0",
+        "pino-abstract-transport": "^3.0.0",
+        "pump": "^3.0.0",
+        "secure-json-parse": "^4.0.0",
+        "sonic-boom": "^4.0.1",
+        "strip-json-comments": "^5.0.2"
+      },
+      "bin": {
+        "pino-pretty": "bin.js"
+      }
+    },
+    "node_modules/pino-pretty/node_modules/pino-abstract-transport": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-3.0.0.tgz",
+      "integrity": "sha512-wlfUczU+n7Hy/Ha5j9a/gZNy7We5+cXp8YL+X+PG8S0KXxw7n/JXA3c46Y0zQznIJ83URJiwy7Lh56WLokNuxg==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.0.0"
+      }
+    },
+    "node_modules/pino-std-serializers": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz",
+      "integrity": "sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==",
+      "license": "MIT"
+    },
+    "node_modules/possible-typed-array-names": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
+    "node_modules/process-warning": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz",
+      "integrity": "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/prom-client": {
+      "version": "15.1.3",
+      "resolved": "https://registry.npmjs.org/prom-client/-/prom-client-15.1.3.tgz",
+      "integrity": "sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api": "^1.4.0",
+        "tdigest": "^0.1.1"
+      },
+      "engines": {
+        "node": "^16 || ^18 || >=20"
+      }
+    },
+    "node_modules/protobufjs": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
+      "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pump": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/quick-format-unescaped": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz",
+      "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==",
+      "license": "MIT"
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz",
+      "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.7.0",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/readable-stream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/real-require": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz",
+      "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12.13.0"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safe-stable-stringify": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
+      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/secure-json-parse": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-4.1.0.tgz",
+      "integrity": "sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/seek-bzip": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.6.tgz",
+      "integrity": "sha512-e1QtP3YL5tWww8uKaOCQ18UxIT2laNBXHjV/S2WYCiK4udiv8lkG89KRIoCjUagnAmCBurjF4zEVX2ByBbnCjQ==",
+      "license": "MIT",
+      "dependencies": {
+        "commander": "^2.8.1"
+      },
+      "bin": {
+        "seek-bunzip": "bin/seek-bunzip",
+        "seek-table": "bin/seek-bzip-table"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/sonic-boom": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.0.tgz",
+      "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==",
+      "license": "MIT",
+      "dependencies": {
+        "atomic-sleep": "^1.0.0"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/string_decoder/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/strip-dirs": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz",
+      "integrity": "sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==",
+      "license": "MIT",
+      "dependencies": {
+        "is-natural-number": "^4.0.1"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.3.tgz",
+      "integrity": "sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.2.tgz",
+      "integrity": "sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==",
+      "license": "MIT",
+      "dependencies": {
+        "bl": "^1.0.0",
+        "buffer-alloc": "^1.2.0",
+        "end-of-stream": "^1.0.0",
+        "fs-constants": "^1.0.0",
+        "readable-stream": "^2.3.0",
+        "to-buffer": "^1.1.1",
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/tdigest": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/tdigest/-/tdigest-0.1.2.tgz",
+      "integrity": "sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==",
+      "license": "MIT",
+      "dependencies": {
+        "bintrees": "1.0.2"
+      }
+    },
+    "node_modules/thread-stream": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
+      "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==",
+      "license": "MIT",
+      "dependencies": {
+        "real-require": "^0.2.0"
+      }
+    },
+    "node_modules/through": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+      "license": "MIT"
+    },
+    "node_modules/to-buffer": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.2.tgz",
+      "integrity": "sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==",
+      "license": "MIT",
+      "dependencies": {
+        "isarray": "^2.0.5",
+        "safe-buffer": "^5.2.1",
+        "typed-array-buffer": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/to-buffer/node_modules/isarray": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+      "license": "MIT"
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/ts-node": {
+      "version": "10.9.2",
+      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
+      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@cspotcode/source-map-support": "^0.8.0",
+        "@tsconfig/node10": "^1.0.7",
+        "@tsconfig/node12": "^1.0.7",
+        "@tsconfig/node14": "^1.0.0",
+        "@tsconfig/node16": "^1.0.2",
+        "acorn": "^8.4.1",
+        "acorn-walk": "^8.1.1",
+        "arg": "^4.1.0",
+        "create-require": "^1.1.0",
+        "diff": "^4.0.1",
+        "make-error": "^1.1.1",
+        "v8-compile-cache-lib": "^3.0.1",
+        "yn": "3.1.1"
+      },
+      "bin": {
+        "ts-node": "dist/bin.js",
+        "ts-node-cwd": "dist/bin-cwd.js",
+        "ts-node-esm": "dist/bin-esm.js",
+        "ts-node-script": "dist/bin-script.js",
+        "ts-node-transpile-only": "dist/bin-transpile.js",
+        "ts-script": "dist/bin-script-deprecated.js"
+      },
+      "peerDependencies": {
+        "@swc/core": ">=1.2.50",
+        "@swc/wasm": ">=1.2.50",
+        "@types/node": "*",
+        "typescript": ">=2.7"
+      },
+      "peerDependenciesMeta": {
+        "@swc/core": {
+          "optional": true
+        },
+        "@swc/wasm": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tsconfig-paths": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
+      "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json5": "^2.2.2",
+        "minimist": "^1.2.6",
+        "strip-bom": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typed-array-buffer": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-typed-array": "^1.1.14"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unbzip2-stream": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
+      "integrity": "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer": "^5.2.1",
+        "through": "^2.3.8"
+      }
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/uuid": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
+      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/esm/bin/uuid"
+      }
+    },
+    "node_modules/v8-compile-cache-lib": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
+      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/validator": {
+      "version": "13.15.23",
+      "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.23.tgz",
+      "integrity": "sha512-4yoz1kEWqUjzi5zsPbAS/903QXSYp0UOtHsPpp7p9rHAw/W+dkInskAE386Fat3oKRROwO98d9ZB0G4cObgUyw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/wav-encoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/wav-encoder/-/wav-encoder-1.3.0.tgz",
+      "integrity": "sha512-FXJdEu2qDOI+wbVYZpu21CS1vPEg5NaxNskBr4SaULpOJMrLE6xkH8dECa7PiS+ZoeyvP7GllWUAxPN3AvFSEw==",
+      "license": "MIT"
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "4.0.0-beta.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
+      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/which-typed-array": {
+      "version": "1.1.19",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
+      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
+      "license": "MIT",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.4",
+        "for-each": "^0.3.5",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "node_modules/yn": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
+      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.1.13.tgz",
+      "integrity": "sha512-AvvthqfqrAhNH9dnfmrfKzX5upOdjUVJYFqNSlkmGf64gRaTzlPwz99IHYnVs28qYAybvAlBV+H7pn0saFY4Ig==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.0",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.0.tgz",
+      "integrity": "sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25 || ^4"
+      }
+    }
+  }
+}
diff --git a/realtime-service/src/package.json b/realtime-service/src/package.json
new file mode 100644
index 0000000..d12a8f1
--- /dev/null
+++ b/realtime-service/src/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "server",
+  "main": "index.js",
+  "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
+  "scripts": {
+    "start": "nodemon -r tsconfig-paths/register index.ts",
+    "start:debug": "node-ts index.ts",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.1",
+    "@types/express-validator": "^3.0.0",
+    "@types/node": "^22.14.0",
+    "@types/ws": "^8.18.1",
+    "nodemon": "^3.1.9",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^5.1.0",
+    "express-validator": "^7.2.1",
+    "groq-sdk": "^0.7.0",
+    "pino": "^9.14.0",
+    "pino-pretty": "^13.1.2",
+    "prom-client": "^15.1.3",
+    "uuid": "^11.1.0",
+    "wav-encoder": "^1.3.0",
+    "ws": "^8.18.1",
+    "zod": "^4.1.13"
+  }
+}
diff --git a/realtime-service/src/tsconfig.json b/realtime-service/src/tsconfig.json
new file mode 100644
index 0000000..fc82f5d
--- /dev/null
+++ b/realtime-service/src/tsconfig.json
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "module": "Node16",
+    "moduleResolution": "node16",
+    "noImplicitAny": true,
+    "resolveJsonModule": true,
+    "target": "es6",
+    "types": ["node"],
+    "outDir": "./dist",
+    "rootDir": "./",
+    "baseUrl": ".",
+    "paths": {
+      "@inworld/runtime/common": ["./node_modules/@inworld/runtime/build/common/export"],
+      "@inworld/runtime/graph": ["./node_modules/@inworld/runtime/build/graph/export"],
+      "@inworld/runtime/graph/nodes": ["./node_modules/@inworld/runtime/build/graph/dsl/nodes/builtin/export"],
+      "@inworld/runtime/graph/components": ["./node_modules/@inworld/runtime/build/graph/dsl/components/export"],
+      "@inworld/runtime/core": ["./node_modules/@inworld/runtime/build/core/export"],
+      "@inworld/runtime/primitives/*": ["./node_modules/@inworld/runtime/build/primitives/*/index"],
+      "@inworld/runtime/telemetry": ["./node_modules/@inworld/runtime/build/telemetry/export"]
+    }
+  }
+}
diff --git a/realtime-service/src/types/index.ts b/realtime-service/src/types/index.ts
new file mode 100644
index 0000000..2a80e1f
--- /dev/null
+++ b/realtime-service/src/types/index.ts
@@ -0,0 +1,108 @@
+import { AudioChunkInterface } from '@inworld/runtime/common';
+import { GraphOutputStream } from '@inworld/runtime/graph';
+
+import { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager';
+
+export enum EVENT_TYPE {
+  TEXT = 'TEXT',
+  AUDIO = 'AUDIO',
+  AUDIO_SESSION_END = 'audioSessionEnd',
+  NEW_INTERACTION = 'newInteraction',
+  CANCEL_RESPONSE = 'CANCEL_RESPONSE',
+}
+
+export enum AUDIO_SESSION_STATE {
+  PROCESSING = 'PROCESSING',
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+}
+
+export interface ChatMessage {
+  id: string;
+  role: string;
+  content: string;
+  tool_call_id?: string; // For tool/function call outputs
+}
+
+export interface Agent {
+  id: string;
+  name: string;
+  description: string;
+  motivation: string;
+  knowledge?: string[];
+}
+
+export interface TextInput {
+  sessionId: string;
+  text: string;
+  interactionId: string;
+  voiceId?: string;
+}
+
+export interface AudioInput {
+  sessionId: string;
+  audio: AudioChunkInterface;
+  state: State;
+  interactionId: string;
+}
+
+export interface AudioStreamInput {
+  sessionId: string;
+  state: State;
+  voiceId?: string;
+}
+
+export interface State {
+  interactionId: string;
+  agent: Agent;
+  userName: string;
+  messages: ChatMessage[];
+  voiceId?: string;
+  tools?: any[];
+  toolChoice?: string | object;
+  eagerness?: 'low' | 'medium' | 'high';
+  output_modalities?: ('text' | 'audio')[];
+}
+
+export interface Connection {
+  apiKey: string;
+  workspaceId: string;
+  state: State;
+  ws: any;
+  unloaded?: true;
+  multimodalStreamManager?: MultimodalStreamManager;
+  currentAudioGraphExecution?: Promise<void>;
+  // Track execution streams so they can be aborted
+  currentAudioExecutionStream?: GraphOutputStream;
+  onSpeechDetected?: (interactionId: string) => void; // Callback when speech is detected (triggers input_audio_buffer.speech_started event)
+  onPartialTranscript?: (text: string, interactionId: string) => void; // Callback for partial transcripts
+}
+
+export type ConnectionsMap = {
+  [sessionId: string]: Connection;
+};
+
+export interface PromptInput {
+  agent: Agent;
+  messages: ChatMessage[];
+  userName: string;
+  userQuery: string;
+}
+
+export interface CreateGraphPropsInterface {
+  llmModelName: string;
+  llmProvider: string;
+  voiceId: string;
+  graphVisualizationEnabled: boolean;
+  connections: ConnectionsMap;
+  ttsModelId: string;
+  useAssemblyAI?: boolean; // Use Assembly.AI streaming STT (should always be true for audio input)
+  assemblyAIApiKey?: string; // Assembly.AI API key (required for audio input)
+  useMocks?: boolean; // Use mock components (FakeTTSComponent, FakeRemoteLLMComponent) instead of real ones
+}
+
+export interface InteractionInfo {
+  sessionId: string;
+  interactionId: string;
+  text: string;
+}
diff --git a/realtime-service/src/types/realtime.ts b/realtime-service/src/types/realtime.ts
new file mode 100644
index 0000000..a71c088
--- /dev/null
+++ b/realtime-service/src/types/realtime.ts
@@ -0,0 +1,526 @@
+/**
+ * OpenAI Realtime API Type Definitions
+ * Based on the OpenAI Realtime API specification
+ */
+
+import { GraphTypes } from '@inworld/runtime/graph';
+
+// ============================================================================
+// Client Events (sent from client to server)
+// ============================================================================
+
+export interface ClientEventBase {
+  event_id?: string;
+}
+
+export interface SessionUpdateEvent extends ClientEventBase {
+  type: 'session.update';
+  session: Partial<SessionConfig>;
+}
+
+export interface InputAudioBufferAppendEvent extends ClientEventBase {
+  type: 'input_audio_buffer.append';
+  audio: string; // base64-encoded audio
+}
+
+export interface InputAudioBufferCommitEvent extends ClientEventBase {
+  type: 'input_audio_buffer.commit';
+}
+
+export interface InputAudioBufferClearEvent extends ClientEventBase {
+  type: 'input_audio_buffer.clear';
+}
+
+export interface ConversationItemCreateEvent extends ClientEventBase {
+  type: 'conversation.item.create';
+  previous_item_id?: string;
+  item: ConversationItem;
+}
+
+export interface ConversationItemTruncateEvent extends ClientEventBase {
+  type: 'conversation.item.truncate';
+  item_id: string;
+  content_index: number;
+  audio_end_ms: number;
+}
+
+export interface ConversationItemDeleteEvent extends ClientEventBase {
+  type: 'conversation.item.delete';
+  item_id: string;
+}
+
+export interface ConversationItemRetrieveEvent extends ClientEventBase {
+  type: 'conversation.item.retrieve';
+  item_id: string;
+}
+
+export interface ResponseCreateEvent extends ClientEventBase {
+  type: 'response.create';
+  response?: ResponseConfig;
+}
+
+export interface ResponseCancelEvent extends ClientEventBase {
+  type: 'response.cancel';
+  response_id?: string;
+}
+
+export type ClientEvent =
+  | SessionUpdateEvent
+  | InputAudioBufferAppendEvent
+  | InputAudioBufferCommitEvent
+  | InputAudioBufferClearEvent
+  | ConversationItemCreateEvent
+  | ConversationItemTruncateEvent
+  | ConversationItemDeleteEvent
+  | ConversationItemRetrieveEvent
+  | ResponseCreateEvent
+  | ResponseCancelEvent;
+
+// ============================================================================
+// Server Events (sent from server to client)
+// ============================================================================
+
+export interface ServerEventBase {
+  event_id: string;
+}
+
+export interface SessionCreatedEvent extends ServerEventBase {
+  type: 'session.created';
+  session: Session;
+}
+
+export interface SessionUpdatedEvent extends ServerEventBase {
+  type: 'session.updated';
+  session: Session;
+}
+
+export interface ConversationItemAddedEvent extends ServerEventBase {
+  type: 'conversation.item.added';
+  previous_item_id: string | null;
+  item: ConversationItem;
+}
+
+export interface ConversationItemDoneEvent extends ServerEventBase {
+  type: 'conversation.item.done';
+  previous_item_id: string | null;
+  item: ConversationItem;
+}
+
+export interface ConversationItemRetrievedEvent extends ServerEventBase {
+  type: 'conversation.item.retrieved';
+  item: ConversationItem;
+}
+
+export interface ConversationItemTruncatedEvent extends ServerEventBase {
+  type: 'conversation.item.truncated';
+  item_id: string;
+  content_index: number;
+  audio_end_ms: number;
+}
+
+export interface ConversationItemDeletedEvent extends ServerEventBase {
+  type: 'conversation.item.deleted';
+  item_id: string;
+}
+
+export interface InputAudioBufferCommittedEvent extends ServerEventBase {
+  type: 'input_audio_buffer.committed';
+  previous_item_id: string | null;
+  item_id: string;
+}
+
+export interface InputAudioBufferClearedEvent extends ServerEventBase {
+  type: 'input_audio_buffer.cleared';
+}
+
+export interface InputAudioBufferSpeechStartedEvent extends ServerEventBase {
+  type: 'input_audio_buffer.speech_started';
+  audio_start_ms: number;
+  item_id: string;
+}
+
+export interface InputAudioBufferSpeechStoppedEvent extends ServerEventBase {
+  type: 'input_audio_buffer.speech_stopped';
+  audio_end_ms: number;
+  item_id: string;
+}
+
+export interface ConversationItemInputAudioTranscriptionDeltaEvent
+  extends ServerEventBase {
+  type: 'conversation.item.input_audio_transcription.delta';
+  item_id: string;
+  content_index: number;
+  delta: string;
+}
+
+export interface ConversationItemInputAudioTranscriptionCompletedEvent
+  extends ServerEventBase {
+  type: 'conversation.item.input_audio_transcription.completed';
+  item_id: string;
+  content_index: number;
+  transcript: string;
+}
+
+export interface ResponseCreatedEvent extends ServerEventBase {
+  type: 'response.created';
+  response: Response;
+}
+
+
+export interface ResponseDoneEvent extends ServerEventBase {
+  type: 'response.done';
+  response: Response;
+}
+
+export interface ResponseOutputItemAddedEvent extends ServerEventBase {
+  type: 'response.output_item.added';
+  response_id: string;
+  output_index: number;
+  item: ConversationItem;
+}
+
+export interface ResponseOutputItemDoneEvent extends ServerEventBase {
+  type: 'response.output_item.done';
+  response_id: string;
+  output_index: number;
+  item: ConversationItem;
+}
+
+export interface ResponseContentPartAddedEvent extends ServerEventBase {
+  type: 'response.content_part.added';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  part: ContentPart;
+}
+
+export interface ResponseContentPartDoneEvent extends ServerEventBase {
+  type: 'response.content_part.done';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  part: ContentPart;
+}
+
+export interface ResponseAudioDeltaEvent extends ServerEventBase {
+  type: 'response.output_audio.delta';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  delta: string; // base64-encoded audio
+}
+
+export interface ResponseAudioDoneEvent extends ServerEventBase {
+  type: 'response.output_audio.done';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+}
+
+export interface ResponseAudioTranscriptDeltaEvent extends ServerEventBase {
+  type: 'response.output_audio_transcript.delta';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  delta: string;
+}
+
+export interface ResponseAudioTranscriptDoneEvent extends ServerEventBase {
+  type: 'response.output_audio_transcript.done';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  transcript: string;
+}
+
+export interface ResponseFunctionCallArgumentsDeltaEvent extends ServerEventBase {
+  type: 'response.function_call_arguments.delta';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  call_id: string;
+  delta: string;
+}
+
+export interface ResponseFunctionCallArgumentsDoneEvent extends ServerEventBase {
+  type: 'response.function_call_arguments.done';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  call_id: string;
+  arguments: string;
+}
+
+export interface ResponseTextDeltaEvent extends ServerEventBase {
+  type: 'response.output_text.delta';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  delta: string;
+}
+
+export interface ResponseTextDoneEvent extends ServerEventBase {
+  type: 'response.output_text.done';
+  response_id: string;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  text: string;
+}
+
+export interface ErrorEvent extends ServerEventBase {
+  type: 'error';
+  error: {
+    type: string;
+    code: string | null;
+    message: string;
+    param: string | null;
+    event_id: string | null;
+  };
+}
+
+export interface RateLimitsUpdatedEvent extends ServerEventBase {
+  type: 'rate_limits.updated';
+  rate_limits: Array<{
+    name: 'requests' | 'tokens';
+    limit: number;
+    remaining: number;
+    reset_seconds: number;
+  }>;
+}
+
+export type ServerEvent =
+  | SessionCreatedEvent
+  | SessionUpdatedEvent
+  | ConversationItemAddedEvent
+  | ConversationItemDoneEvent
+  | ConversationItemRetrievedEvent
+  | ConversationItemTruncatedEvent
+  | ConversationItemDeletedEvent
+  | InputAudioBufferCommittedEvent
+  | InputAudioBufferClearedEvent
+  | InputAudioBufferSpeechStartedEvent
+  | InputAudioBufferSpeechStoppedEvent
+  | ConversationItemInputAudioTranscriptionDeltaEvent
+  | ConversationItemInputAudioTranscriptionCompletedEvent
+  | ResponseCreatedEvent
+  | ResponseDoneEvent
+  | ResponseOutputItemAddedEvent
+  | ResponseOutputItemDoneEvent
+  | ResponseContentPartAddedEvent
+  | ResponseContentPartDoneEvent
+  | ResponseAudioDeltaEvent
+  | ResponseAudioDoneEvent
+  | ResponseAudioTranscriptDeltaEvent
+  | ResponseAudioTranscriptDoneEvent
+  | ResponseFunctionCallArgumentsDeltaEvent
+  | ResponseFunctionCallArgumentsDoneEvent
+  | ResponseTextDeltaEvent
+  | ResponseTextDoneEvent
+  | ErrorEvent
+  | RateLimitsUpdatedEvent;
+
+// ============================================================================
+// Data Types
+// ============================================================================
+
+export interface AudioInputConfig {
+  format: {
+    type: 'audio/pcm';
+    rate: 24000;
+  };
+  transcription?: {
+    model: string;
+    language?: string;
+  } | null;
+  noise_reduction?: {
+    type: 'near_field' | 'far_field';
+  } | null;
+  turn_detection?: TurnDetection | null;
+}
+
+export interface AudioOutputConfig {
+  format: {
+    type: 'audio/pcm';
+    rate: 24000;
+  };
+  voice: string;
+  speed?: number;
+}
+
+export interface SessionConfig {
+  output_modalities?: ('text' | 'audio')[];
+  instructions?: string;
+  audio?: {
+    input?: Partial<AudioInputConfig>;
+    output?: Partial<AudioOutputConfig>;
+  };
+  tools?: Tool[];
+  tool_choice?: 'auto' | 'none' | 'required';
+  temperature?: number;
+  max_output_tokens?: number | 'inf';
+  truncation?: 'auto' | 'disabled';
+  prompt?: string | null;
+  tracing?: string | null;
+  include?: string[] | null;
+}
+
+export interface Session {
+  type: 'realtime';
+  id: string;
+  object: 'realtime.session';
+  model: string;
+  output_modalities: ('text' | 'audio')[];
+  instructions: string;
+  audio: {
+    input: AudioInputConfig;
+    output: AudioOutputConfig;
+  };
+  tools: Tool[];
+  tool_choice: 'auto' | 'none' | 'required';
+  temperature: number;
+  max_output_tokens: number | 'inf';
+  truncation: 'auto' | 'disabled';
+  prompt: string | null;
+  tracing: string | null;
+  expires_at: number;
+  include: string[] | null;
+}
+
+// Turn detection can be either server_vad (simple) or semantic_vad (advanced with eagerness)
+export interface ServerVADTurnDetection {
+  type: 'server_vad';
+  threshold?: number;
+  prefix_padding_ms?: number;
+  silence_duration_ms?: number;
+  idle_timeout_ms?: number | null;
+  create_response?: boolean;
+  interrupt_response?: boolean;
+}
+
+export interface SemanticVADTurnDetection {
+  type: 'semantic_vad';
+  eagerness?: 'low' | 'medium' | 'high' | 'auto';
+  create_response?: boolean;
+  interrupt_response?: boolean;
+}
+
+export type TurnDetection = ServerVADTurnDetection | SemanticVADTurnDetection;
+
+export interface Tool {
+  type: 'function';
+  name: string;
+  description?: string;
+  parameters?: Record<string, any>;
+}
+
+export interface ConversationItem {
+  id?: string;
+  type: 'message' | 'function_call' | 'function_call_output';
+  object?: 'realtime.item';
+  status?: 'completed' | 'in_progress' | 'incomplete';
+  role?: 'user' | 'assistant' | 'system';
+  content?: ContentPart[];
+  call_id?: string;
+  name?: string;
+  arguments?: string;
+  output?: string;
+}
+
+// Specific types for different conversation items
+export interface MessageItem extends ConversationItem {
+  type: 'message';
+  role: 'user' | 'assistant' | 'system';
+  content: ContentPart[];
+}
+
+export interface FunctionCallItem extends ConversationItem {
+  type: 'function_call';
+  call_id: string;
+  name: string;
+  arguments: string;
+}
+
+export interface FunctionCallOutputItem extends ConversationItem {
+  type: 'function_call_output';
+  call_id: string;
+  output: string;
+}
+
+export interface ContentPart {
+  type: 'text' | 'audio' | 'input_text' | 'input_audio';
+  text?: string;
+  audio?: string; // base64-encoded
+  transcript?: string;
+}
+
+export interface ResponseConfig {
+  modalities?: ('text' | 'audio')[];
+  instructions?: string;
+  voice?: string;
+  output_audio_format?: 'pcm16' | 'g711_ulaw' | 'g711_alaw';
+  tools?: Tool[];
+  tool_choice?: 'auto' | 'none' | 'required';
+  temperature?: number;
+  max_output_tokens?: number | 'inf';
+}
+
+export interface Response {
+  id: string;
+  object: 'realtime.response';
+  status: 'in_progress' | 'completed' | 'cancelled' | 'failed' | 'incomplete';
+  status_details?: {
+    type: 'completed' | 'cancelled' | 'incomplete' | 'failed';
+    reason?: string;
+    error?: {
+      type: string;
+      code?: string;
+    };
+  } | null;
+  output: ConversationItem[];
+  conversation_id?: string | null;
+  output_modalities?: ('text' | 'audio')[];
+  max_output_tokens?: number | 'inf';
+  audio?: {
+    output: AudioOutputConfig;
+  };
+  usage?: {
+    total_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+    input_token_details?: {
+      cached_tokens?: number;
+      text_tokens?: number;
+      image_tokens?: number;
+      audio_tokens?: number;
+    };
+    output_token_details?: {
+      text_tokens?: number;
+      audio_tokens?: number;
+    };
+  } | null;
+  metadata?: any | null;
+}
+
+// ============================================================================
+// Session State
+// ============================================================================
+
+export interface RealtimeSession {
+  id: string;
+  session: Session;
+  conversationItems: ConversationItem[];
+  inputAudioBuffer: number[];
+  currentResponse: Response | null;
+  audioStartMs: number;
+  // Store active streams so they can be aborted on cancel
+  currentContentStream?: GraphTypes.ContentStream | null;
+  currentTTSStream?: GraphTypes.TTSOutputStream | null;
+}
diff --git a/realtime-service/src/types/settings.ts b/realtime-service/src/types/settings.ts
new file mode 100644
index 0000000..4fd332e
--- /dev/null
+++ b/realtime-service/src/types/settings.ts
@@ -0,0 +1,45 @@
+/**
+ * Maps OpenAI eagerness levels to AssemblyAI turn detection settings
+ * Based on AssemblyAI's recommended configurations for different use cases
+ */
+
+export interface AssemblyAITurnDetectionSettings {
+  endOfTurnConfidenceThreshold: number;
+  minEndOfTurnSilenceWhenConfident: number;
+  maxTurnSilence: number;
+  description: string;
+}
+
+/**
+ * Get AssemblyAI turn detection settings for a given eagerness level
+ * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
+ * @returns AssemblyAI turn detection settings including threshold values and description
+ */
+export function getAssemblyAISettingsForEagerness(
+  eagerness: 'low' | 'medium' | 'high' = 'medium'
+): AssemblyAITurnDetectionSettings {
+  switch (eagerness) {
+    case 'high': // Aggressive - VERY responsive
+      return {
+        endOfTurnConfidenceThreshold: 0.4,
+        minEndOfTurnSilenceWhenConfident: 160,
+        maxTurnSilence: 320,
+        description: 'Aggressive - VERY quick responses, ideal for rapid Q&A (Agent Assist, IVR)',
+      };
+    case 'medium': // Balanced (default)
+      return {
+        endOfTurnConfidenceThreshold: 0.4,
+        minEndOfTurnSilenceWhenConfident: 400,
+        maxTurnSilence: 1280,
+        description: 'Balanced - Natural conversation flow (Customer Support, Tech Support)',
+      };
+    case 'low': // Conservative - VERY patient
+      return {
+        endOfTurnConfidenceThreshold: 0.7,
+        minEndOfTurnSilenceWhenConfident: 800,
+        maxTurnSilence: 3000,
+        description: 'Conservative - VERY patient, allows long thinking pauses (Complex inquiries)',
+      };
+  }
+}
+
diff --git a/realtime-service/tsconfig.test.json b/realtime-service/tsconfig.test.json
new file mode 100644
index 0000000..96174c8
--- /dev/null
+++ b/realtime-service/tsconfig.test.json
@@ -0,0 +1,21 @@
+{
+  "extends": "./src/tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "types": ["node", "jest"],
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "__tests__/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}
+
diff --git a/realtime-service/yarn.lock b/realtime-service/yarn.lock
new file mode 100644
index 0000000..42d12b0
--- /dev/null
+++ b/realtime-service/yarn.lock
@@ -0,0 +1,8 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+ws@^8.18.3:
+  version "8.18.3"
+  resolved "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz"
+  integrity sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==

From 5a0a505587fd3a74992cc28d4262ffa861d72d3b Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:01:33 -0800
Subject: [PATCH 03/49] 0.9 working ok end to end in Spanish

---
 backend/components/audio/audio_utils.ts       |   71 -
 .../graphs/conversation-graph.ts              |    6 +-
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  166 +-
 .../nodes/dialog_prompt_builder_node.ts       |    6 +-
 .../graphs/nodes/interaction_queue_node.ts    |    2 +-
 .../graphs/nodes/state_update_node.ts         |    2 +-
 .../graphs/nodes/text_input_node.ts           |    2 +-
 .../graphs/nodes/transcript_extractor_node.ts |    2 +-
 .../graphs/nodes/tts_request_builder_node.ts  |    4 +-
 backend/helpers/audio_utils.ts                |  199 +
 backend/helpers/connection-manager.ts         |   13 +-
 .../multimodal_stream_manager.ts              |    2 +
 backend/server.ts                             |    2 +-
 backend/types/index.ts                        |    2 +-
 frontend/.gitignore                           |   24 +
 frontend/README.md                            |   73 +
 frontend/eslint.config.js                     |   23 +
 frontend/index.html                           |  108 +-
 frontend/js/audio-processor.js                |   59 -
 frontend/js/chat-ui.js                        |  417 ---
 frontend/js/flashcard-ui.js                   |  179 -
 frontend/js/ios-audio-workarounds.js          |  578 ---
 frontend/js/main.js                           |  923 -----
 frontend/package-lock.json                    | 3212 ++++++++++++++++
 frontend/package.json                         |   30 +
 frontend/public/audio-processor.js            |   72 +
 frontend/public/vite.svg                      |    1 +
 frontend/src/App.tsx                          |   33 +
 frontend/src/components/ChatSection.tsx       |  166 +
 frontend/src/components/Flashcard.tsx         |   61 +
 frontend/src/components/FlashcardsSection.tsx |  125 +
 frontend/src/components/Header.tsx            |   50 +
 frontend/src/components/Message.tsx           |   86 +
 frontend/src/components/StreamingMessage.tsx  |   94 +
 .../src/components/TranslationTooltip.tsx     |   70 +
 frontend/src/context/AppContext.tsx           |  619 ++++
 frontend/src/hooks/useTranslator.ts           |   26 +
 frontend/src/hooks/useTypewriter.ts           |   63 +
 frontend/src/main.tsx                         |    9 +
 .../services/AudioHandler.ts}                 |  106 +-
 .../services/AudioPlayer.ts}                  |  204 +-
 .../storage.js => src/services/Storage.ts}    |   99 +-
 .../services/Translator.ts}                   |   61 +-
 .../services/WebSocketClient.ts}              |  145 +-
 frontend/{ => src}/styles/main.css            |    0
 frontend/src/types/global.d.ts                |   11 +
 frontend/src/types/index.ts                   |  139 +
 frontend/src/vite-env.d.ts                    |    1 +
 frontend/tsconfig.app.json                    |   28 +
 frontend/tsconfig.json                        |    7 +
 frontend/tsconfig.node.json                   |   26 +
 frontend/vite.config.ts                       |   15 +
 realtime-service/.env-sample                  |   39 -
 realtime-service/Makefile                     |   53 -
 realtime-service/README.md                    |   91 -
 realtime-service/__tests__/README.md          |  469 ---
 realtime-service/__tests__/api/README.md      |  312 --
 .../__tests__/api/realtime-api.spec.ts        |  885 -----
 .../__tests__/api/websocket-server-helper.ts  |  133 -
 .../__tests__/api/websocket-test-helper.ts    |  311 --
 realtime-service/__tests__/config.ts          |    8 -
 realtime-service/__tests__/setup.ts           |    9 -
 realtime-service/__tests__/test-setup.ts      |   32 -
 .../__tests__/utils/graph-test-helpers.ts     |   71 -
 .../__tests__/utils/mock-helpers.ts           |   93 -
 realtime-service/jest.config.js               |   34 -
 realtime-service/load-tests/README.md         |   61 -
 realtime-service/load-tests/load_test.js      |  425 ---
 realtime-service/load-tests/package.json      |   30 -
 realtime-service/mock/echo_ws_server.go       |   50 -
 realtime-service/package-lock.json            |   33 -
 realtime-service/package.json                 |   26 -
 realtime-service/src/.gitignore               |   32 -
 realtime-service/src/REALTIME_API.md          |  313 --
 realtime-service/src/components/app.ts        |   78 -
 .../src/components/audio/audio_utils.ts       |   91 -
 .../audio/multimodal_stream_manager.ts        |  125 -
 .../audio/realtime_audio_handler.ts           |  213 --
 .../src/components/graphs/graph.ts            |  308 --
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  855 -----
 .../nodes/dialog_prompt_builder_node.ts       |   87 -
 .../graphs/nodes/interaction_queue_node.ts    |  178 -
 .../graphs/nodes/state_update_node.ts         |   67 -
 .../graphs/nodes/text_input_node.ts           |   75 -
 .../graphs/nodes/text_output_stream_node.ts   |   29 -
 .../graphs/nodes/transcript_extractor_node.ts |   63 -
 .../graphs/nodes/tts_request_builder_node.ts  |   64 -
 .../graphs/realtime_graph_executor.ts         | 1180 ------
 .../realtime/realtime_event_factory.ts        |  499 ---
 .../realtime/realtime_message_handler.ts      |  168 -
 .../realtime/realtime_session_manager.ts      |  508 ---
 .../src/components/runtime_app_manager.ts     |  140 -
 realtime-service/src/config.ts                |   15 -
 realtime-service/src/helpers.ts               |   65 -
 realtime-service/src/index.ts                 |  319 --
 realtime-service/src/log-helpers.ts           |   88 -
 realtime-service/src/logger.ts                |   66 -
 realtime-service/src/package-lock.json        | 3273 -----------------
 realtime-service/src/package.json             |   36 -
 realtime-service/src/tsconfig.json            |   23 -
 realtime-service/src/types/index.ts           |  108 -
 realtime-service/src/types/realtime.ts        |  526 ---
 realtime-service/src/types/settings.ts        |   45 -
 realtime-service/tsconfig.test.json           |   21 -
 realtime-service/yarn.lock                    |    8 -
 105 files changed, 5764 insertions(+), 15489 deletions(-)
 delete mode 100644 backend/components/audio/audio_utils.ts
 rename backend/{components => }/graphs/conversation-graph.ts (98%)
 rename backend/{components => }/graphs/nodes/assembly_ai_stt_ws_node.ts (80%)
 rename backend/{components => }/graphs/nodes/dialog_prompt_builder_node.ts (93%)
 rename backend/{components => }/graphs/nodes/interaction_queue_node.ts (99%)
 rename backend/{components => }/graphs/nodes/state_update_node.ts (96%)
 rename backend/{components => }/graphs/nodes/text_input_node.ts (95%)
 rename backend/{components => }/graphs/nodes/transcript_extractor_node.ts (96%)
 rename backend/{components => }/graphs/nodes/tts_request_builder_node.ts (93%)
 create mode 100644 backend/helpers/audio_utils.ts
 rename backend/{components/audio => helpers}/multimodal_stream_manager.ts (95%)
 create mode 100644 frontend/.gitignore
 create mode 100644 frontend/README.md
 create mode 100644 frontend/eslint.config.js
 delete mode 100644 frontend/js/audio-processor.js
 delete mode 100644 frontend/js/chat-ui.js
 delete mode 100644 frontend/js/flashcard-ui.js
 delete mode 100644 frontend/js/ios-audio-workarounds.js
 delete mode 100644 frontend/js/main.js
 create mode 100644 frontend/package-lock.json
 create mode 100644 frontend/package.json
 create mode 100644 frontend/public/audio-processor.js
 create mode 100644 frontend/public/vite.svg
 create mode 100644 frontend/src/App.tsx
 create mode 100644 frontend/src/components/ChatSection.tsx
 create mode 100644 frontend/src/components/Flashcard.tsx
 create mode 100644 frontend/src/components/FlashcardsSection.tsx
 create mode 100644 frontend/src/components/Header.tsx
 create mode 100644 frontend/src/components/Message.tsx
 create mode 100644 frontend/src/components/StreamingMessage.tsx
 create mode 100644 frontend/src/components/TranslationTooltip.tsx
 create mode 100644 frontend/src/context/AppContext.tsx
 create mode 100644 frontend/src/hooks/useTranslator.ts
 create mode 100644 frontend/src/hooks/useTypewriter.ts
 create mode 100644 frontend/src/main.tsx
 rename frontend/{js/audio-handler.js => src/services/AudioHandler.ts} (74%)
 rename frontend/{js/audio-player.js => src/services/AudioPlayer.ts} (54%)
 rename frontend/{js/storage.js => src/services/Storage.ts} (70%)
 rename frontend/{js/translator.js => src/services/Translator.ts} (53%)
 rename frontend/{js/websocket-client.js => src/services/WebSocketClient.ts} (56%)
 rename frontend/{ => src}/styles/main.css (100%)
 create mode 100644 frontend/src/types/global.d.ts
 create mode 100644 frontend/src/types/index.ts
 create mode 100644 frontend/src/vite-env.d.ts
 create mode 100644 frontend/tsconfig.app.json
 create mode 100644 frontend/tsconfig.json
 create mode 100644 frontend/tsconfig.node.json
 create mode 100644 frontend/vite.config.ts
 delete mode 100644 realtime-service/.env-sample
 delete mode 100644 realtime-service/Makefile
 delete mode 100644 realtime-service/README.md
 delete mode 100644 realtime-service/__tests__/README.md
 delete mode 100644 realtime-service/__tests__/api/README.md
 delete mode 100644 realtime-service/__tests__/api/realtime-api.spec.ts
 delete mode 100644 realtime-service/__tests__/api/websocket-server-helper.ts
 delete mode 100644 realtime-service/__tests__/api/websocket-test-helper.ts
 delete mode 100644 realtime-service/__tests__/config.ts
 delete mode 100644 realtime-service/__tests__/setup.ts
 delete mode 100644 realtime-service/__tests__/test-setup.ts
 delete mode 100644 realtime-service/__tests__/utils/graph-test-helpers.ts
 delete mode 100644 realtime-service/__tests__/utils/mock-helpers.ts
 delete mode 100644 realtime-service/jest.config.js
 delete mode 100644 realtime-service/load-tests/README.md
 delete mode 100644 realtime-service/load-tests/load_test.js
 delete mode 100644 realtime-service/load-tests/package.json
 delete mode 100644 realtime-service/mock/echo_ws_server.go
 delete mode 100644 realtime-service/package-lock.json
 delete mode 100644 realtime-service/package.json
 delete mode 100644 realtime-service/src/.gitignore
 delete mode 100644 realtime-service/src/REALTIME_API.md
 delete mode 100644 realtime-service/src/components/app.ts
 delete mode 100644 realtime-service/src/components/audio/audio_utils.ts
 delete mode 100644 realtime-service/src/components/audio/multimodal_stream_manager.ts
 delete mode 100644 realtime-service/src/components/audio/realtime_audio_handler.ts
 delete mode 100644 realtime-service/src/components/graphs/graph.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/state_update_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/text_input_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
 delete mode 100644 realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
 delete mode 100644 realtime-service/src/components/graphs/realtime_graph_executor.ts
 delete mode 100644 realtime-service/src/components/realtime/realtime_event_factory.ts
 delete mode 100644 realtime-service/src/components/realtime/realtime_message_handler.ts
 delete mode 100644 realtime-service/src/components/realtime/realtime_session_manager.ts
 delete mode 100644 realtime-service/src/components/runtime_app_manager.ts
 delete mode 100644 realtime-service/src/config.ts
 delete mode 100644 realtime-service/src/helpers.ts
 delete mode 100644 realtime-service/src/index.ts
 delete mode 100644 realtime-service/src/log-helpers.ts
 delete mode 100644 realtime-service/src/logger.ts
 delete mode 100644 realtime-service/src/package-lock.json
 delete mode 100644 realtime-service/src/package.json
 delete mode 100644 realtime-service/src/tsconfig.json
 delete mode 100644 realtime-service/src/types/index.ts
 delete mode 100644 realtime-service/src/types/realtime.ts
 delete mode 100644 realtime-service/src/types/settings.ts
 delete mode 100644 realtime-service/tsconfig.test.json
 delete mode 100644 realtime-service/yarn.lock

diff --git a/backend/components/audio/audio_utils.ts b/backend/components/audio/audio_utils.ts
deleted file mode 100644
index f404a38..0000000
--- a/backend/components/audio/audio_utils.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Audio utility functions for format conversion
- */
-
-/**
- * Convert Float32Array audio data to Int16Array (PCM16)
- */
-export function float32ToPCM16(float32Data: Float32Array): Int16Array {
-  const pcm16 = new Int16Array(float32Data.length);
-  for (let i = 0; i < float32Data.length; i++) {
-    // Clamp to [-1, 1] range and convert to Int16 range [-32768, 32767]
-    const s = Math.max(-1, Math.min(1, float32Data[i]));
-    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
-  }
-  return pcm16;
-}
-
-/**
- * Convert Int16Array (PCM16) to Float32Array
- */
-export function pcm16ToFloat32(pcm16Data: Int16Array): Float32Array {
-  const float32 = new Float32Array(pcm16Data.length);
-  for (let i = 0; i < pcm16Data.length; i++) {
-    float32[i] = pcm16Data[i] / 32768.0;
-  }
-  return float32;
-}
-
-/**
- * Convert audio data to PCM16 base64 string for WebSocket transmission
- */
-export function convertToPCM16Base64(
-  audioData: number[] | Float32Array | string | undefined,
-  _sampleRate: number | undefined,
-  _logPrefix: string = 'Audio'
-): string | null {
-  if (!audioData) {
-    return null;
-  }
-
-  let base64Data: string;
-
-  if (typeof audioData === 'string') {
-    // Already base64 encoded
-    base64Data = audioData;
-  } else {
-    // Convert Float32 array to PCM16 base64
-    const float32Data = Array.isArray(audioData)
-      ? new Float32Array(audioData)
-      : audioData;
-    const pcm16Data = float32ToPCM16(float32Data);
-    base64Data = Buffer.from(pcm16Data.buffer).toString('base64');
-  }
-
-  return base64Data;
-}
-
-/**
- * Decode base64 audio to Float32Array
- * Note: Node.js Buffer objects share ArrayBuffers with offsets, so we need to copy
- */
-export function decodeBase64ToFloat32(base64Audio: string): Float32Array {
-  const buffer = Buffer.from(base64Audio, 'base64');
-  // Create a clean copy to avoid Node.js Buffer's internal ArrayBuffer sharing
-  const cleanArray = new Uint8Array(buffer.length);
-  for (let i = 0; i < buffer.length; i++) {
-    cleanArray[i] = buffer[i];
-  }
-  const int16Array = new Int16Array(cleanArray.buffer);
-  return pcm16ToFloat32(int16Array);
-}
diff --git a/backend/components/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
similarity index 98%
rename from backend/components/graphs/conversation-graph.ts
rename to backend/graphs/conversation-graph.ts
index b873b7d..5f64f43 100644
--- a/backend/components/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -35,12 +35,12 @@ import {
   TextInput,
   INPUT_SAMPLE_RATE,
   TTS_SAMPLE_RATE,
-} from '../../types/index.js';
+} from '../types/index.js';
 import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
-} from '../../config/languages.js';
-import { getAssemblyAISettingsForEagerness } from '../../types/settings.js';
+} from '../config/languages.js';
+import { getAssemblyAISettingsForEagerness } from '../types/settings.js';
 
 export interface ConversationGraphConfig {
   assemblyAIApiKey: string;
diff --git a/backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
similarity index 80%
rename from backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts
rename to backend/graphs/nodes/assembly_ai_stt_ws_node.ts
index ec4c7c5..7dd0bec 100644
--- a/backend/components/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -16,10 +16,10 @@ import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import WebSocket from 'ws';
 import { v4 as uuidv4 } from 'uuid';
 
-import { Connection } from '../../../types/index.js';
+import { Connection } from '../../types/index.js';
 // Settings imported but used via constructor config
-// import { getAssemblyAISettingsForEagerness } from '../../../types/settings.js';
-import { float32ToPCM16 } from '../../audio/audio_utils.js';
+// import { getAssemblyAISettingsForEagerness } from '../../types/settings.js';
+import { float32ToPCM16 } from '../../helpers/audio_utils.js';
 
 /**
  * Configuration interface for AssemblyAISTTWebSocketNode
@@ -59,10 +59,11 @@ class AssemblyAISession {
   private lastActivityTime: number = Date.now();
   private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
 
-  // Audio buffering for AssemblyAI's chunk size requirements (50-1000ms)
-  private audioBuffer: Int16Array = new Int16Array(0);
-  // Buffer to ~100ms worth of audio before sending (1600 samples at 16kHz)
-  private readonly MIN_SAMPLES_TO_SEND = 1600;
+  // Track completed turns to prevent duplicate processing
+  private lastCompletedTranscript: string = '';
+  private newSpeechReceived: boolean = false;
+  private lastTurnTimestamp: number = 0;
+  private readonly TURN_DEBOUNCE_MS = 500; // Minimum time between accepting turns
 
   constructor(
     public readonly sessionId: string,
@@ -158,40 +159,13 @@ class AssemblyAISession {
     }
   }
 
-  public sendAudio(pcm16Data: Int16Array): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      return;
-    }
-
-    // Append new audio to buffer
-    const newBuffer = new Int16Array(this.audioBuffer.length + pcm16Data.length);
-    newBuffer.set(this.audioBuffer, 0);
-    newBuffer.set(pcm16Data, this.audioBuffer.length);
-    this.audioBuffer = newBuffer;
-
-    // Send if we have enough samples (100ms worth at 16kHz = 1600 samples)
-    if (this.audioBuffer.length >= this.MIN_SAMPLES_TO_SEND) {
-      this.ws.send(Buffer.from(this.audioBuffer.buffer));
-      this.audioBuffer = new Int16Array(0);
-      this.resetInactivityTimer();
-    }
-  }
-
   /**
-   * Flush any remaining buffered audio (call before closing)
+   * Send audio data directly to AssemblyAI (no buffering)
    */
-  public flushAudio(): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.audioBuffer.length > 0) {
-      // Pad to minimum size if needed
-      if (this.audioBuffer.length < 800) {
-        // Pad to at least 50ms (800 samples)
-        const paddedBuffer = new Int16Array(800);
-        paddedBuffer.set(this.audioBuffer, 0);
-        this.ws.send(Buffer.from(paddedBuffer.buffer));
-      } else {
-        this.ws.send(Buffer.from(this.audioBuffer.buffer));
-      }
-      this.audioBuffer = new Int16Array(0);
+  public sendAudio(pcm16Data: Int16Array): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(Buffer.from(pcm16Data.buffer));
+      this.resetInactivityTimer();
     }
   }
 
@@ -246,6 +220,68 @@ class AssemblyAISession {
 
     this.closeWebSocket();
   }
+
+  /**
+   * Mark that new speech was received (partial transcript)
+   */
+  public markNewSpeechReceived(): void {
+    this.newSpeechReceived = true;
+  }
+
+  /**
+   * Check if a turn should be accepted or rejected as duplicate
+   * Returns true if the turn is valid and should be processed
+   */
+  public shouldAcceptTurn(transcript: string): boolean {
+    const now = Date.now();
+
+    // Check debounce - if a turn was just completed, reject
+    if (this.lastTurnTimestamp > 0 && now - this.lastTurnTimestamp < this.TURN_DEBOUNCE_MS) {
+      console.log(`[AssemblyAI] Rejecting turn - within debounce period (${now - this.lastTurnTimestamp}ms)`);
+      return false;
+    }
+
+    // Normalize transcripts for comparison (lowercase, remove punctuation, trim)
+    const normalizeText = (text: string) =>
+      text.toLowerCase().replace(/[.,!?;:'"]/g, '').replace(/\s+/g, ' ').trim();
+
+    const normalizedNew = normalizeText(transcript);
+    const normalizedLast = normalizeText(this.lastCompletedTranscript);
+
+    // If no new speech was received since last turn, check for duplicate content
+    if (!this.newSpeechReceived && this.lastCompletedTranscript) {
+      // Check if transcripts are similar (allowing for minor formatting differences)
+      const isSimilar = normalizedNew === normalizedLast ||
+                       normalizedNew.includes(normalizedLast) ||
+                       normalizedLast.includes(normalizedNew);
+
+      if (isSimilar) {
+        console.log(`[AssemblyAI] Rejecting turn - duplicate content without new speech`);
+        console.log(`  Last: "${this.lastCompletedTranscript.substring(0, 50)}..."`);
+        console.log(`  New:  "${transcript.substring(0, 50)}..."`);
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Mark that a turn was completed - store for deduplication
+   */
+  public markTurnCompleted(transcript: string): void {
+    this.lastTurnTimestamp = Date.now();
+    this.lastCompletedTranscript = transcript;
+    this.newSpeechReceived = false; // Reset for next turn
+    console.log(`[AssemblyAI] Turn completed, transcript stored for deduplication`);
+  }
+
+  /**
+   * Reset turn tracking state (call when starting fresh interaction)
+   */
+  public resetTurnTracking(): void {
+    this.newSpeechReceived = false;
+  }
 }
 
 /**
@@ -300,8 +336,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.maxTurnSilence = config.maxTurnSilence || 1280;
     this.defaultLanguage = config.language || 'es';
 
+    const defaultModel = this.defaultLanguage === 'en'
+      ? 'universal-streaming-english'
+      : 'universal-streaming-multilingual';
     console.log(
-      `[AssemblyAI] Configured with [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.defaultLanguage}]`
+      `[AssemblyAI] Configured with [model:${defaultModel}] [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.defaultLanguage}]`
     );
   }
 
@@ -324,18 +363,31 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       }
     }
 
+    // Determine speech model based on language
+    // AssemblyAI's streaming v3 API:
+    // - 'universal-streaming-english' for English only (default)
+    // - 'universal-streaming-multilingual' for other languages (Spanish, Japanese, etc.)
+    const isEnglish = language === 'en';
+    const speechModel = isEnglish
+      ? 'universal-streaming-english'
+      : 'universal-streaming-multilingual';
+
+    const languageCode = language === 'en' ? 'en' : 'multi';
+
     const params = new URLSearchParams({
       sample_rate: this.sampleRate.toString(),
+      encoding: 'pcm_s16le', // Signed 16-bit little-endian PCM
       format_turns: this.formatTurns.toString(),
       end_of_turn_confidence_threshold: endOfTurnThreshold.toString(),
       min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
       max_turn_silence: maxSilence.toString(),
-      language: language,
+      speech_model: speechModel,
+      language: languageCode
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
     console.log(
-      `[AssemblyAI] Connecting with [lang:${language}] [threshold:${endOfTurnThreshold}]`
+      `[AssemblyAI] Connecting with [model:${speechModel}] [lang:${language}] [threshold:${endOfTurnThreshold}]`
     );
 
     return url;
@@ -443,6 +495,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
         if (msgType === 'Turn') {
           if (session?.shouldStopProcessing) {
+            console.log(`[AssemblyAI] Ignoring Turn - processing stopped [iteration:${iteration}]`);
             return;
           }
 
@@ -453,9 +506,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
           if (!transcript) return;
 
           if (!isFinal) {
-            // Partial transcript
+            // Partial transcript - mark that we're receiving new speech
             const textToSend = utterance || transcript;
             if (textToSend) {
+              console.log(`[AssemblyAI] Partial [iteration:${iteration}]: "${textToSend.substring(0, 30)}..."`);
+
+              // Mark new speech received BEFORE sending partial
+              session?.markNewSpeechReceived();
+
               this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
 
               if (connection?.onSpeechDetected && !speechDetected) {
@@ -467,14 +525,28 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             return;
           }
 
-          // Final transcript
+          // Final transcript - check for duplicates
           console.log(
-            `[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
+            `[AssemblyAI] Turn candidate [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
+          );
+
+          // Check if we should accept this turn (not a duplicate)
+          if (session && !session.shouldAcceptTurn(transcript)) {
+            console.log(`[AssemblyAI] Turn rejected as duplicate [iteration:${iteration}]`);
+            return;
+          }
+
+          // Accept the turn
+          console.log(
+            `[AssemblyAI] Turn ACCEPTED [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
           );
 
           transcriptText = transcript;
           turnDetected = true;
-          if (session) session.shouldStopProcessing = true;
+          if (session) {
+            session.shouldStopProcessing = true;
+            session.markTurnCompleted(transcript);
+          }
           turnResolve(transcript);
         } else if (msgType === 'Termination') {
           console.log(`[AssemblyAI] Session terminated [iteration:${iteration}]`);
@@ -562,8 +634,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
           if (maxDurationTimeout) {
             clearTimeout(maxDurationTimeout);
           }
-          // Flush any remaining buffered audio
-          session?.flushAudio();
         }
       })();
 
diff --git a/backend/components/graphs/nodes/dialog_prompt_builder_node.ts b/backend/graphs/nodes/dialog_prompt_builder_node.ts
similarity index 93%
rename from backend/components/graphs/nodes/dialog_prompt_builder_node.ts
rename to backend/graphs/nodes/dialog_prompt_builder_node.ts
index 73d05f7..036f079 100644
--- a/backend/components/graphs/nodes/dialog_prompt_builder_node.ts
+++ b/backend/graphs/nodes/dialog_prompt_builder_node.ts
@@ -10,9 +10,9 @@
 
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
-import { ConnectionsMap, State } from '../../../types/index.js';
-import { getLanguageConfig } from '../../../config/languages.js';
-import { conversationTemplate } from '../../../helpers/prompt-templates.js';
+import { ConnectionsMap, State } from '../../types/index.js';
+import { getLanguageConfig } from '../../config/languages.js';
+import { conversationTemplate } from '../../helpers/prompt-templates.js';
 
 export class DialogPromptBuilderNode extends CustomNode {
   constructor(props: {
diff --git a/backend/components/graphs/nodes/interaction_queue_node.ts b/backend/graphs/nodes/interaction_queue_node.ts
similarity index 99%
rename from backend/components/graphs/nodes/interaction_queue_node.ts
rename to backend/graphs/nodes/interaction_queue_node.ts
index 5c129ae..ae345d2 100644
--- a/backend/components/graphs/nodes/interaction_queue_node.ts
+++ b/backend/graphs/nodes/interaction_queue_node.ts
@@ -9,7 +9,7 @@
  */
 
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../../types/index.js';
+import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../types/index.js';
 
 export class InteractionQueueNode extends CustomNode {
   private connections: ConnectionsMap;
diff --git a/backend/components/graphs/nodes/state_update_node.ts b/backend/graphs/nodes/state_update_node.ts
similarity index 96%
rename from backend/components/graphs/nodes/state_update_node.ts
rename to backend/graphs/nodes/state_update_node.ts
index fb013c7..23f7fed 100644
--- a/backend/components/graphs/nodes/state_update_node.ts
+++ b/backend/graphs/nodes/state_update_node.ts
@@ -10,7 +10,7 @@
 
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { v4 as uuidv4 } from 'uuid';
-import { ConnectionsMap, State } from '../../../types/index.js';
+import { ConnectionsMap, State } from '../../types/index.js';
 
 export class StateUpdateNode extends CustomNode {
   private connections: ConnectionsMap;
diff --git a/backend/components/graphs/nodes/text_input_node.ts b/backend/graphs/nodes/text_input_node.ts
similarity index 95%
rename from backend/components/graphs/nodes/text_input_node.ts
rename to backend/graphs/nodes/text_input_node.ts
index ba3111d..fd91f6a 100644
--- a/backend/components/graphs/nodes/text_input_node.ts
+++ b/backend/graphs/nodes/text_input_node.ts
@@ -9,7 +9,7 @@
 
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { v4 as uuidv4 } from 'uuid';
-import { ConnectionsMap, State, TextInput } from '../../../types/index.js';
+import { ConnectionsMap, State, TextInput } from '../../types/index.js';
 
 export class TextInputNode extends CustomNode {
   private connections: ConnectionsMap;
diff --git a/backend/components/graphs/nodes/transcript_extractor_node.ts b/backend/graphs/nodes/transcript_extractor_node.ts
similarity index 96%
rename from backend/components/graphs/nodes/transcript_extractor_node.ts
rename to backend/graphs/nodes/transcript_extractor_node.ts
index c4b33d4..1b47e1c 100644
--- a/backend/components/graphs/nodes/transcript_extractor_node.ts
+++ b/backend/graphs/nodes/transcript_extractor_node.ts
@@ -6,7 +6,7 @@
 
 import { DataStreamWithMetadata } from '@inworld/runtime';
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import { InteractionInfo } from '../../../types/index.js';
+import { InteractionInfo } from '../../types/index.js';
 
 export class TranscriptExtractorNode extends CustomNode {
   constructor(props?: { id?: string; reportToClient?: boolean }) {
diff --git a/backend/components/graphs/nodes/tts_request_builder_node.ts b/backend/graphs/nodes/tts_request_builder_node.ts
similarity index 93%
rename from backend/components/graphs/nodes/tts_request_builder_node.ts
rename to backend/graphs/nodes/tts_request_builder_node.ts
index 1af2ca8..df1caa4 100644
--- a/backend/components/graphs/nodes/tts_request_builder_node.ts
+++ b/backend/graphs/nodes/tts_request_builder_node.ts
@@ -6,8 +6,8 @@
  */
 
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
-import { ConnectionsMap } from '../../../types/index.js';
-import { getLanguageConfig } from '../../../config/languages.js';
+import { ConnectionsMap } from '../../types/index.js';
+import { getLanguageConfig } from '../../config/languages.js';
 
 export class TTSRequestBuilderNode extends CustomNode {
   private connections: ConnectionsMap;
diff --git a/backend/helpers/audio_utils.ts b/backend/helpers/audio_utils.ts
new file mode 100644
index 0000000..6084f08
--- /dev/null
+++ b/backend/helpers/audio_utils.ts
@@ -0,0 +1,199 @@
+/**
+ * Audio utility functions for format conversion
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Audio debug logging
+const DEBUG_AUDIO = process.env.DEBUG_AUDIO === 'true';
+const AUDIO_DEBUG_DIR = path.join(process.cwd(), 'audio-debug');
+
+// Ensure debug directory exists
+if (DEBUG_AUDIO && !fs.existsSync(AUDIO_DEBUG_DIR)) {
+  fs.mkdirSync(AUDIO_DEBUG_DIR, { recursive: true });
+  console.log(`[AudioDebug] Created debug directory: ${AUDIO_DEBUG_DIR}`);
+}
+
+// Audio buffer for accumulating chunks per session
+const audioBuffers: Map<string, Float32Array[]> = new Map();
+
+/**
+ * Add audio chunk to debug buffer
+ */
+export function debugAddAudioChunk(sessionId: string, float32Data: Float32Array): void {
+  if (!DEBUG_AUDIO) return;
+
+  if (!audioBuffers.has(sessionId)) {
+    audioBuffers.set(sessionId, []);
+    console.log(`[AudioDebug] Started collecting audio for session ${sessionId}`);
+  }
+
+  audioBuffers.get(sessionId)!.push(new Float32Array(float32Data));
+}
+
+/**
+ * Save accumulated audio to WAV file
+ */
+export function debugSaveAudio(sessionId: string, sampleRate: number = 16000): string | null {
+  if (!DEBUG_AUDIO) return null;
+
+  const chunks = audioBuffers.get(sessionId);
+  if (!chunks || chunks.length === 0) {
+    console.log(`[AudioDebug] No audio to save for session ${sessionId}`);
+    return null;
+  }
+
+  // Combine all chunks
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const combined = new Float32Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  // Convert to WAV
+  const wavBuffer = float32ToWav(combined, sampleRate);
+
+  // Save to file
+  const filename = `audio_${sessionId}_${Date.now()}.wav`;
+  const filepath = path.join(AUDIO_DEBUG_DIR, filename);
+  fs.writeFileSync(filepath, wavBuffer);
+
+  console.log(`[AudioDebug] Saved ${combined.length} samples (${(combined.length / sampleRate).toFixed(2)}s) to ${filepath}`);
+
+  // Clear buffer
+  audioBuffers.delete(sessionId);
+
+  return filepath;
+}
+
+/**
+ * Log audio stats for debugging
+ */
+export function debugLogAudioStats(sessionId: string, float32Data: Float32Array): void {
+  if (!DEBUG_AUDIO) return;
+
+  const min = Math.min(...float32Data);
+  const max = Math.max(...float32Data);
+  const avg = float32Data.reduce((a, b) => a + b, 0) / float32Data.length;
+  const nonZero = float32Data.filter(v => Math.abs(v) > 0.001).length;
+
+  console.log(`[AudioDebug] Session ${sessionId.slice(-8)}: samples=${float32Data.length}, min=${min.toFixed(4)}, max=${max.toFixed(4)}, avg=${avg.toFixed(4)}, nonZero=${nonZero}/${float32Data.length}`);
+}
+
+/**
+ * Convert Float32 audio to WAV buffer
+ */
+function float32ToWav(samples: Float32Array, sampleRate: number): Buffer {
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const bytesPerSample = bitsPerSample / 8;
+  const blockAlign = numChannels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+  const dataSize = samples.length * bytesPerSample;
+  const headerSize = 44;
+  const totalSize = headerSize + dataSize;
+
+  const buffer = Buffer.alloc(totalSize);
+  let offset = 0;
+
+  // RIFF header
+  buffer.write('RIFF', offset); offset += 4;
+  buffer.writeUInt32LE(totalSize - 8, offset); offset += 4;
+  buffer.write('WAVE', offset); offset += 4;
+
+  // fmt chunk
+  buffer.write('fmt ', offset); offset += 4;
+  buffer.writeUInt32LE(16, offset); offset += 4; // chunk size
+  buffer.writeUInt16LE(1, offset); offset += 2; // PCM format
+  buffer.writeUInt16LE(numChannels, offset); offset += 2;
+  buffer.writeUInt32LE(sampleRate, offset); offset += 4;
+  buffer.writeUInt32LE(byteRate, offset); offset += 4;
+  buffer.writeUInt16LE(blockAlign, offset); offset += 2;
+  buffer.writeUInt16LE(bitsPerSample, offset); offset += 2;
+
+  // data chunk
+  buffer.write('data', offset); offset += 4;
+  buffer.writeUInt32LE(dataSize, offset); offset += 4;
+
+  // Write samples as 16-bit PCM
+  for (let i = 0; i < samples.length; i++) {
+    const s = Math.max(-1, Math.min(1, samples[i]));
+    const val = s < 0 ? s * 0x8000 : s * 0x7FFF;
+    buffer.writeInt16LE(Math.round(val), offset);
+    offset += 2;
+  }
+
+  return buffer;
+}
+
+/**
+ * Convert Float32Array audio data to Int16Array (PCM16)
+ */
+export function float32ToPCM16(float32Data: Float32Array): Int16Array {
+  const pcm16 = new Int16Array(float32Data.length);
+  for (let i = 0; i < float32Data.length; i++) {
+    // Clamp to [-1, 1] range and convert to Int16 range [-32768, 32767]
+    const s = Math.max(-1, Math.min(1, float32Data[i]));
+    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+  }
+  return pcm16;
+}
+
+/**
+ * Convert Int16Array (PCM16) to Float32Array
+ */
+export function pcm16ToFloat32(pcm16Data: Int16Array): Float32Array {
+  const float32 = new Float32Array(pcm16Data.length);
+  for (let i = 0; i < pcm16Data.length; i++) {
+    float32[i] = pcm16Data[i] / 32768.0;
+  }
+  return float32;
+}
+
+/**
+ * Convert audio data to PCM16 base64 string for WebSocket transmission
+ */
+export function convertToPCM16Base64(
+  audioData: number[] | Float32Array | string | undefined,
+  _sampleRate: number | undefined,
+  _logPrefix: string = 'Audio'
+): string | null {
+  if (!audioData) {
+    return null;
+  }
+
+  let base64Data: string;
+
+  if (typeof audioData === 'string') {
+    // Already base64 encoded
+    base64Data = audioData;
+  } else {
+    // Convert Float32 array to PCM16 base64
+    const float32Data = Array.isArray(audioData)
+      ? new Float32Array(audioData)
+      : audioData;
+    const pcm16Data = float32ToPCM16(float32Data);
+    base64Data = Buffer.from(pcm16Data.buffer).toString('base64');
+  }
+
+  return base64Data;
+}
+
+/**
+ * Decode base64 audio to Float32Array
+ * Frontend sends Float32 audio data directly (4 bytes per sample)
+ * Note: Node.js Buffer objects share ArrayBuffers with offsets, so we need to copy
+ */
+export function decodeBase64ToFloat32(base64Audio: string): Float32Array {
+  const buffer = Buffer.from(base64Audio, 'base64');
+  // Create a clean copy to avoid Node.js Buffer's internal ArrayBuffer sharing
+  const cleanArray = new Uint8Array(buffer.length);
+  for (let i = 0; i < buffer.length; i++) {
+    cleanArray[i] = buffer[i];
+  }
+  // Interpret bytes directly as Float32 (4 bytes per sample)
+  return new Float32Array(cleanArray.buffer);
+}
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index f395862..219cd17 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -11,9 +11,9 @@
 import { WebSocket } from 'ws';
 import { GraphTypes } from '@inworld/runtime/graph';
 
-import { ConversationGraphWrapper } from '../components/graphs/conversation-graph.js';
-import { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager.js';
-import { decodeBase64ToFloat32 } from '../components/audio/audio_utils.js';
+import { ConversationGraphWrapper } from '../graphs/conversation-graph.js';
+import { MultimodalStreamManager } from './multimodal_stream_manager.js';
+import { decodeBase64ToFloat32, debugAddAudioChunk, debugLogAudioStats, debugSaveAudio } from './audio_utils.js';
 import { ConnectionsMap, INPUT_SAMPLE_RATE, TTS_SAMPLE_RATE } from '../types/index.js';
 import {
   getLanguageConfig,
@@ -327,6 +327,10 @@ export class ConnectionManager {
       // Decode base64 to Float32Array
       const float32Data = decodeBase64ToFloat32(base64Audio);
 
+      // Debug: log audio stats and collect for WAV export
+      debugLogAudioStats(this.sessionId, float32Data);
+      debugAddAudioChunk(this.sessionId, float32Data);
+
       // Push to multimodal stream
       this.multimodalStreamManager.pushAudio({
         data: Array.from(float32Data),
@@ -566,6 +570,9 @@ export class ConnectionManager {
     console.log(`[ConnectionManager] Destroying session ${this.sessionId}`);
     this.isDestroyed = true;
 
+    // Save debug audio if enabled (DEBUG_AUDIO=true)
+    debugSaveAudio(this.sessionId, INPUT_SAMPLE_RATE);
+
     // End the multimodal stream
     this.multimodalStreamManager.end();
 
diff --git a/backend/components/audio/multimodal_stream_manager.ts b/backend/helpers/multimodal_stream_manager.ts
similarity index 95%
rename from backend/components/audio/multimodal_stream_manager.ts
rename to backend/helpers/multimodal_stream_manager.ts
index 212fe55..175bec8 100644
--- a/backend/components/audio/multimodal_stream_manager.ts
+++ b/backend/helpers/multimodal_stream_manager.ts
@@ -29,6 +29,8 @@ export class MultimodalStreamManager {
     }
 
     // Create GraphTypes.Audio object and wrap in MultimodalContent
+    // Note: GraphTypes.Audio requires number[] - conversion from Float32Array is unavoidable
+    // due to SDK constraint. If chunk.data is already number[], we pass it directly.
     const audioData = new GraphTypes.Audio({
       data: Array.isArray(chunk.data) ? chunk.data : Array.from(chunk.data),
       sampleRate: chunk.sampleRate,
diff --git a/backend/server.ts b/backend/server.ts
index 110f7e2..a07f2ce 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -27,7 +27,7 @@ import { telemetry, stopInworldRuntime } from '@inworld/runtime';
 import { MetricType } from '@inworld/runtime/telemetry';
 
 // Import new 0.9 components
-import { ConversationGraphWrapper } from './components/graphs/conversation-graph.js';
+import { ConversationGraphWrapper } from './graphs/conversation-graph.js';
 import { ConnectionManager } from './helpers/connection-manager.js';
 import { ConnectionsMap } from './types/index.js';
 
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 90c7965..230273d 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -3,7 +3,7 @@
  */
 
 import { WebSocket } from 'ws';
-import type { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager.js';
+import type { MultimodalStreamManager } from '../helpers/multimodal_stream_manager.js';
 import type { GraphOutputStream } from '@inworld/runtime/graph';
 import type { IntroductionState } from '../helpers/introduction-state-processor.js';
 
diff --git a/frontend/.gitignore b/frontend/.gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/frontend/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/frontend/README.md b/frontend/README.md
new file mode 100644
index 0000000..d2e7761
--- /dev/null
+++ b/frontend/README.md
@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js
new file mode 100644
index 0000000..5e6b472
--- /dev/null
+++ b/frontend/eslint.config.js
@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])
diff --git a/frontend/index.html b/frontend/index.html
index 7eb9aab..edf10b7 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -1,100 +1,16 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Aprendemo</title>
-    <link rel="stylesheet" href="styles/main.css">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Roboto+Serif:opsz,wght@8..144,100..900&display=swap" rel="stylesheet">
-</head>
-<body>
-    <header class="header">
-        <div class="container">
-            <h1 class="logo">Aprendemo</h1>
-            <div class="header-controls">
-                <div class="language-selector">
-                    <select id="languageSelect" class="language-dropdown" disabled>
-                        <option value="es">🇲🇽 Spanish</option>
-                    </select>
-                </div>
-                <div class="status-indicator">
-                    <span class="status-dot" id="statusDot"></span>
-                    <span class="status-text" id="statusText">Connecting...</span>
-                </div>
-            </div>
-        </div>
-    </header>
-
-    <main class="main">
-        <div class="container">
-            <div class="app-grid">
-                <!-- Chat Column -->
-                <section class="chat-section">
-                    <div class="section-header">
-                        <h2>Conversation</h2>
-                        <div class="button-group">
-                            <button class="restart-button" id="restartButton" disabled>
-                                <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
-                                    <path d="M21.5 2v6h-6M21.5 8A9.5 9.5 0 0 0 12 2.5 9.5 9.5 0 0 0 2.5 12 9.5 9.5 0 0 0 12 21.5 9.5 9.5 0 0 0 21.5 12"/>
-                                </svg>
-                            </button>
-                            <button class="mic-button" id="micButton" disabled>
-                                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-                                    <path d="M12 1a4 4 0 0 0-4 4v6a4 4 0 0 0 8 0V5a4 4 0 0 0-4-4z"/>
-                                    <path d="M19 10v1a7 7 0 0 1-14 0v-1"/>
-                                    <line x1="12" y1="19" x2="12" y2="23"/>
-                                    <line x1="8" y1="23" x2="16" y2="23"/>
-                                </svg>
-                            </button>
-                        </div>
-                    </div>
-                    
-                    <div class="chat-container">
-                        <div class="messages" id="messages"></div>
-                        <div class="current-transcript" id="currentTranscript"></div>
-                    </div>
-                </section>
-
-                <!-- Flashcards Column -->
-                <section class="flashcards-section">
-                    <div class="section-header">
-                        <h2>Flashcards</h2>
-                        <span class="card-count" id="cardCount">0 cards</span>
-                    </div>
-                    
-                    <div class="flashcards-container">
-                        <div class="flashcards-grid" id="flashcardsGrid">
-                            <div class="empty-state">
-                                <p></p>
-                            </div>
-                        </div>
-                    </div>
-                </section>
-            </div>
-        </div>
-    </main>
-
-    <!-- Hidden audio element for iOS playback -->
-    <audio id="iosAudioElement" style="display: none;" playsinline webkit-playsinline></audio>
-
-    <!-- iOS Audio Workarounds - Load conditionally -->
-    <script>
-        // Detect iOS and load workarounds if needed
-        const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) || 
-                      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
-        
-        if (isIOS) {
-            const script = document.createElement('script');
-            script.src = 'js/ios-audio-workarounds.js';
-            script.onload = () => {
-                console.log('[Main] iOS audio workarounds loaded');
-            };
-            document.head.appendChild(script);
-        }
-    </script>
-    
-    <script type="module" src="js/main.js"></script>
-</body>
+    <link href="https://fonts.googleapis.com/css2?family=Roboto+Serif:ital,opsz,wght@0,8..144,100..900;1,8..144,100..900&display=swap" rel="stylesheet">
+    <title>Aprendemo</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
 </html>
diff --git a/frontend/js/audio-processor.js b/frontend/js/audio-processor.js
deleted file mode 100644
index d4517f6..0000000
--- a/frontend/js/audio-processor.js
+++ /dev/null
@@ -1,59 +0,0 @@
-class AudioProcessor extends AudioWorkletProcessor {
-  constructor(options) {
-    super();
-    this.sourceSampleRate = options.processorOptions.sourceSampleRate;
-    this.targetSampleRate = 16000;
-    this.resampleRatio = this.sourceSampleRate / this.targetSampleRate;
-    this.buffer = null;
-  }
-
-  process(inputs) {
-    const inputChannel = inputs[0][0];
-    if (!inputChannel) return true;
-
-    const currentLength = this.buffer ? this.buffer.length : 0;
-    const newBuffer = new Float32Array(currentLength + inputChannel.length);
-    if (this.buffer) {
-      newBuffer.set(this.buffer, 0);
-    }
-    newBuffer.set(inputChannel, currentLength);
-    this.buffer = newBuffer;
-
-    // Put stuff back into 16k
-    const numOutputSamples = Math.floor(
-      this.buffer.length / this.resampleRatio
-    );
-    if (numOutputSamples === 0) return true;
-
-    const resampledData = new Float32Array(numOutputSamples);
-    for (let i = 0; i < numOutputSamples; i++) {
-      const correspondingInputIndex = i * this.resampleRatio;
-      const lowerIndex = Math.floor(correspondingInputIndex);
-      const upperIndex = Math.ceil(correspondingInputIndex);
-      const interpolationFactor = correspondingInputIndex - lowerIndex;
-
-      const lowerValue = this.buffer[lowerIndex] || 0;
-      const upperValue = this.buffer[upperIndex] || 0;
-
-      resampledData[i] =
-        lowerValue + (upperValue - lowerValue) * interpolationFactor;
-    }
-
-    const consumedInputSamples = numOutputSamples * this.resampleRatio;
-    this.buffer = this.buffer.slice(Math.round(consumedInputSamples));
-
-    // Convert Float32Array to Int16Array
-    const int16Array = new Int16Array(resampledData.length);
-    for (let i = 0; i < resampledData.length; i++) {
-      int16Array[i] = Math.max(
-        -32768,
-        Math.min(32767, resampledData[i] * 32768)
-      );
-    }
-
-    this.port.postMessage(int16Array.buffer, [int16Array.buffer]);
-    return true;
-  }
-}
-
-registerProcessor('audio-processor', AudioProcessor);
diff --git a/frontend/js/chat-ui.js b/frontend/js/chat-ui.js
deleted file mode 100644
index 3ebfd61..0000000
--- a/frontend/js/chat-ui.js
+++ /dev/null
@@ -1,417 +0,0 @@
-import { translator } from './translator.js';
-
-export class ChatUI {
-  constructor() {
-    this.messagesContainer = document.getElementById('messages');
-    this.transcriptContainer = document.getElementById('currentTranscript');
-    this.typewriterTimers = new Map(); // Track active typewriter effects
-    this.typewriterSpeed = 25; // milliseconds per character
-    this.llmTypewriterCallback = null; // Callback for when LLM typewriter completes
-    
-    // Translation tooltip
-    this.translationTooltip = this._createTranslationTooltip();
-    this.activeHoverElement = null;
-    this.hoverTimeout = null;
-    this.hideTimeout = null;
-  }
-
-  _createTranslationTooltip() {
-    const tooltip = document.createElement('div');
-    tooltip.className = 'translation-tooltip';
-    tooltip.innerHTML = `
-      <div class="translation-content">
-        <span class="translation-text"></span>
-      </div>
-      <div class="translation-loading">
-        <span></span><span></span><span></span>
-      </div>
-    `;
-    document.body.appendChild(tooltip);
-    
-    // Keep tooltip visible when hovering over it
-    tooltip.addEventListener('mouseenter', () => {
-      if (this.hideTimeout) {
-        clearTimeout(this.hideTimeout);
-        this.hideTimeout = null;
-      }
-    });
-    
-    tooltip.addEventListener('mouseleave', () => {
-      this._hideTooltip();
-    });
-    
-    return tooltip;
-  }
-
-  _showTooltip(element, text) {
-    const rect = element.getBoundingClientRect();
-    const tooltip = this.translationTooltip;
-    
-    // Position tooltip above the message
-    tooltip.style.left = `${rect.left + window.scrollX}px`;
-    tooltip.style.top = `${rect.top + window.scrollY - 8}px`;
-    tooltip.style.maxWidth = `${Math.min(rect.width + 40, 400)}px`;
-    
-    // Show loading state
-    tooltip.classList.add('visible', 'loading');
-    tooltip.querySelector('.translation-text').textContent = '';
-    
-    // Fetch translation
-    translator.translate(text, 'en', 'auto')
-      .then(translation => {
-        if (this.activeHoverElement === element) {
-          tooltip.querySelector('.translation-text').textContent = translation;
-          tooltip.classList.remove('loading');
-          
-          // Reposition after content loads (in case size changed)
-          requestAnimationFrame(() => {
-            const tooltipRect = tooltip.getBoundingClientRect();
-            tooltip.style.top = `${rect.top + window.scrollY - tooltipRect.height - 8}px`;
-          });
-        }
-      })
-      .catch(error => {
-        console.error('[ChatUI] Translation failed:', error);
-        if (this.activeHoverElement === element) {
-          tooltip.querySelector('.translation-text').textContent = 'Translation unavailable';
-          tooltip.classList.remove('loading');
-        }
-      });
-  }
-
-  _hideTooltip() {
-    this.translationTooltip.classList.remove('visible', 'loading');
-    this.activeHoverElement = null;
-  }
-
-  _setupTranslationHover(element) {
-    element.addEventListener('mouseenter', () => {
-      if (this.hideTimeout) {
-        clearTimeout(this.hideTimeout);
-        this.hideTimeout = null;
-      }
-      
-      // Small delay before showing tooltip to avoid flickering
-      this.hoverTimeout = setTimeout(() => {
-        this.activeHoverElement = element;
-        const text = element.textContent.replace('▊', '').trim(); // Remove cursor
-        if (text) {
-          this._showTooltip(element, text);
-        }
-      }, 300);
-    });
-
-    element.addEventListener('mouseleave', () => {
-      if (this.hoverTimeout) {
-        clearTimeout(this.hoverTimeout);
-        this.hoverTimeout = null;
-      }
-      
-      // Delay hiding to allow moving to tooltip
-      this.hideTimeout = setTimeout(() => {
-        this._hideTooltip();
-      }, 150);
-    });
-  }
-
-  render(
-    chatHistory,
-    currentTranscript,
-    currentLLMResponse,
-    pendingTranscription,
-    streamingLLMResponse,
-    isRecording,
-    speechDetected
-  ) {
-    this.renderMessages(
-      chatHistory,
-      pendingTranscription,
-      streamingLLMResponse,
-      currentTranscript,
-      isRecording,
-      speechDetected
-    );
-    this.renderCurrentTranscript(currentTranscript);
-  }
-
-  renderMessages(
-    messages,
-    pendingTranscription,
-    streamingLLMResponse,
-    currentTranscript,
-    isRecording,
-    speechDetected
-  ) {
-    // Only clear and rebuild if the conversation history changed
-    const currentHistoryLength = this.messagesContainer.querySelectorAll(
-      '.message:not(.streaming)'
-    ).length;
-    if (currentHistoryLength !== messages.length) {
-      this.messagesContainer.innerHTML = '';
-
-      // Render existing conversation history
-      messages.forEach((message) => {
-        const messageElement = this.createMessageElement(message);
-        this.messagesContainer.appendChild(messageElement);
-      });
-    }
-
-    // Handle real-time transcript updates (while recording and speech detected)
-    // Show immediately when VAD activates, even before transcript text arrives
-    const existingRealtimeTranscript = document.getElementById(
-      'realtime-transcript'
-    );
-    if (speechDetected && isRecording && !pendingTranscription) {
-      if (!existingRealtimeTranscript) {
-        const userMessage = this.createRealtimeTranscriptElement();
-        userMessage.id = 'realtime-transcript';
-        this.messagesContainer.appendChild(userMessage);
-      }
-      // Update the transcript in real-time (no typewriter effect)
-      // Show 3-dot loading animation if no text yet, otherwise show the actual transcript
-      const transcriptElement = document.getElementById('realtime-transcript');
-      if (transcriptElement) {
-        const textNode = transcriptElement.querySelector('.transcript-text');
-        const loadingDots = transcriptElement.querySelector('.loading-dots');
-        if (currentTranscript) {
-          if (textNode) textNode.textContent = currentTranscript;
-          if (loadingDots) loadingDots.style.display = 'none';
-        } else {
-          if (textNode) textNode.textContent = '';
-          if (loadingDots) loadingDots.style.display = 'flex';
-        }
-        this.scrollToBottom();
-      }
-    } else if (existingRealtimeTranscript) {
-      existingRealtimeTranscript.remove();
-    }
-
-    // Handle pending user transcription (final transcription)
-    const existingUserStreaming = document.getElementById(
-      'pending-transcription'
-    );
-    if (pendingTranscription) {
-      // Remove real-time transcript if it exists
-      if (existingRealtimeTranscript) {
-        existingRealtimeTranscript.remove();
-      }
-      if (!existingUserStreaming) {
-        const userMessage = this.createMessageElement({
-          role: 'learner',
-          content: '',
-        });
-        userMessage.classList.add('streaming');
-        userMessage.id = 'pending-transcription';
-        this.messagesContainer.appendChild(userMessage);
-        // Only start typewriter for new transcriptions
-        this.startTypewriter(
-          'pending-transcription',
-          pendingTranscription,
-          this.typewriterSpeed * 0.8
-        );
-      }
-      // Don't restart typewriter if element already exists
-    } else if (existingUserStreaming) {
-      existingUserStreaming.remove();
-      this.clearTypewriter('pending-transcription');
-    }
-
-    // Handle streaming LLM response
-    const existingLLMStreaming = document.getElementById(
-      'streaming-llm-response'
-    );
-    if (streamingLLMResponse) {
-      console.log(
-        '[ChatUI] Handling streaming LLM response:',
-        streamingLLMResponse
-      );
-      if (!existingLLMStreaming) {
-        console.log(
-          '[ChatUI] Creating new streaming LLM element and starting typewriter'
-        );
-        const assistantMessage = this.createStreamingMessageElement('');
-        assistantMessage.id = 'streaming-llm-response';
-        this.messagesContainer.appendChild(assistantMessage);
-        // Only start typewriter for new LLM responses
-        this.startTypewriter(
-          'streaming-llm-response',
-          streamingLLMResponse,
-          this.typewriterSpeed,
-          this.llmTypewriterCallback
-        );
-      }
-      // Don't restart typewriter if element already exists
-    } else if (existingLLMStreaming) {
-      console.log('[ChatUI] Removing existing LLM streaming element');
-      // Clear typewriter first (this will call the completion callback)
-      this.clearTypewriter('streaming-llm-response');
-      // Then remove the element
-      existingLLMStreaming.remove();
-    }
-
-    this.scrollToBottom();
-  }
-
-  createMessageElement(message) {
-    const div = document.createElement('div');
-    div.className = `message ${message.role}`;
-    div.textContent = message.content;
-    
-    // Add translation hover for teacher (LLM) messages
-    if (message.role === 'teacher') {
-      this._setupTranslationHover(div);
-    }
-    
-    return div;
-  }
-
-  createStreamingMessageElement(content) {
-    const div = document.createElement('div');
-    div.className = 'message teacher streaming';
-
-    // Create text node for content
-    const textNode = document.createTextNode(content);
-    div.appendChild(textNode);
-
-    // Add typing indicator
-    const cursor = document.createElement('span');
-    cursor.className = 'streaming-cursor';
-    cursor.textContent = '▊';
-    div.appendChild(cursor);
-
-    // Add translation hover for streaming teacher messages too
-    this._setupTranslationHover(div);
-
-    return div;
-  }
-
-  createRealtimeTranscriptElement() {
-    const div = document.createElement('div');
-    div.className = 'message learner streaming realtime';
-
-    // Create container for text
-    const textNode = document.createElement('span');
-    textNode.className = 'transcript-text';
-    div.appendChild(textNode);
-
-    // Add 3-dot loading animation
-    const loadingDots = document.createElement('span');
-    loadingDots.className = 'loading-dots';
-    loadingDots.innerHTML = '<span></span><span></span><span></span>';
-    div.appendChild(loadingDots);
-
-    return div;
-  }
-
-  renderCurrentTranscript(transcript) {
-    if (transcript) {
-      this.transcriptContainer.textContent = transcript;
-    } else {
-      this.transcriptContainer.textContent = '';
-    }
-  }
-
-  startTypewriter(elementId, fullText, speed, onComplete) {
-    const element = document.getElementById(elementId);
-    if (!element) {
-      // Element doesn't exist, call completion callback immediately if provided
-      if (onComplete) {
-        console.log(
-          `[Typewriter] Element ${elementId} not found, calling completion callback immediately`
-        );
-        onComplete();
-      }
-      return;
-    }
-
-    // Clear any existing timer for this element
-    if (this.typewriterTimers.has(elementId)) {
-      const existingTimer = this.typewriterTimers.get(elementId);
-      clearInterval(existingTimer.timer || existingTimer);
-      this.typewriterTimers.delete(elementId);
-
-      // If there was a previous timer with a callback, call it now since we're replacing it
-      if (existingTimer.onComplete) {
-        existingTimer.onComplete();
-      }
-    }
-
-    // Get the text content node (accounting for streaming cursor)
-    const textContent = element.querySelector('.streaming-cursor')
-      ? element.childNodes[0]
-      : element;
-
-    // Start fresh - clear the content and start typing from beginning
-    textContent.textContent = '';
-    let currentIndex = 0;
-
-    console.log(`[Typewriter] Starting ${elementId}, target: "${fullText}"`);
-
-    const timer = setInterval(() => {
-      // Check if element still exists
-      const currentElement = document.getElementById(elementId);
-      if (!currentElement) {
-        console.log(
-          `[Typewriter] Element ${elementId} removed, completing immediately`
-        );
-        clearInterval(timer);
-        this.typewriterTimers.delete(elementId);
-        if (onComplete) {
-          onComplete();
-        }
-        return;
-      }
-
-      if (currentIndex < fullText.length) {
-        const newText = fullText.substring(0, currentIndex + 1);
-        textContent.textContent = newText;
-        currentIndex++;
-        this.scrollToBottom();
-      } else {
-        console.log(`[Typewriter] Complete: ${elementId}`);
-        clearInterval(timer);
-        this.typewriterTimers.delete(elementId);
-
-        // Call completion callback if provided
-        if (onComplete) {
-          onComplete();
-        }
-      }
-    }, speed);
-
-    this.typewriterTimers.set(elementId, { timer, fullText, onComplete });
-  }
-
-  clearTypewriter(elementId) {
-    if (this.typewriterTimers.has(elementId)) {
-      const timerData = this.typewriterTimers.get(elementId);
-      clearInterval(timerData.timer || timerData);
-
-      // If there's a completion callback, call it before clearing
-      // This ensures the text gets finalized even if typewriter is interrupted
-      if (timerData.onComplete) {
-        console.log(
-          `[Typewriter] Clearing ${elementId}, calling completion callback`
-        );
-        timerData.onComplete();
-      }
-
-      this.typewriterTimers.delete(elementId);
-    }
-  }
-
-  clearAllTypewriters() {
-    this.typewriterTimers.forEach((timerData, elementId) => {
-      clearInterval(timerData.timer || timerData);
-    });
-    this.typewriterTimers.clear();
-  }
-
-  setLLMTypewriterCallback(callback) {
-    this.llmTypewriterCallback = callback;
-  }
-
-  scrollToBottom() {
-    this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
-  }
-}
diff --git a/frontend/js/flashcard-ui.js b/frontend/js/flashcard-ui.js
deleted file mode 100644
index 1d887da..0000000
--- a/frontend/js/flashcard-ui.js
+++ /dev/null
@@ -1,179 +0,0 @@
-export class FlashcardUI {
-  constructor() {
-    this.flashcardsGrid = document.getElementById('flashcardsGrid');
-    this.cardCount = document.getElementById('cardCount');
-    this.flashcards = [];
-    this.currentLanguage = 'es';
-  }
-
-  render(flashcards, languageCode = 'es') {
-    this.flashcards = flashcards;
-    this.currentLanguage = languageCode;
-    this.updateCardCount(flashcards.length);
-    this.renderFlashcards(flashcards);
-  }
-
-  addFlashcards(newFlashcards) {
-    // Add new flashcards to the existing collection
-    this.flashcards = [...this.flashcards, ...newFlashcards];
-    this.render(this.flashcards, this.currentLanguage);
-  }
-
-  updateCardCount(count) {
-    if (count >= 1) {
-      this.cardCount.textContent = `Export ${count} card${count !== 1 ? 's' : ''} to Anki`;
-      this.cardCount.style.cursor = 'pointer';
-      this.cardCount.style.color = '#666';
-      this.cardCount.style.textDecoration = 'underline';
-      this.cardCount.onclick = () => this.exportToAnki();
-    } else {
-      this.cardCount.textContent = `${count} card${count !== 1 ? 's' : ''}`;
-      this.cardCount.style.cursor = 'default';
-      this.cardCount.style.color = 'inherit';
-      this.cardCount.style.textDecoration = 'none';
-      this.cardCount.onclick = null;
-    }
-  }
-
-  renderFlashcards(flashcards) {
-    this.flashcardsGrid.innerHTML = '';
-
-    if (flashcards.length === 0) {
-      this.renderEmptyState();
-      return;
-    }
-
-    // Show only the latest flashcards, scroll to see older ones
-    const sortedFlashcards = [...flashcards].sort((a, b) => {
-      const timeA = new Date(a.timestamp || 0).getTime();
-      const timeB = new Date(b.timestamp || 0).getTime();
-      return timeB - timeA; // Most recent first
-    });
-
-    sortedFlashcards.forEach((flashcard) => {
-      const cardElement = this.createFlashcardElement(flashcard);
-      this.flashcardsGrid.appendChild(cardElement);
-    });
-  }
-
-  renderEmptyState() {
-    const emptyState = document.createElement('div');
-    emptyState.className = 'empty-state';
-    emptyState.innerHTML = '';
-    this.flashcardsGrid.appendChild(emptyState);
-  }
-
-  createFlashcardElement(flashcard) {
-    const card = document.createElement('div');
-    card.className = 'flashcard';
-
-    // Support both new 'targetWord' and legacy 'spanish' field
-    const targetWord = flashcard.targetWord || flashcard.spanish || flashcard.word || '';
-
-    card.innerHTML = `
-            <div class="flashcard-inner">
-                <div class="flashcard-front">
-                    <div class="flashcard-target-word">${this.escapeHtml(targetWord)}</div>
-                </div>
-                <div class="flashcard-back">
-                    <div class="flashcard-english">${this.escapeHtml(flashcard.english || flashcard.translation || '')}</div>
-                    <div class="flashcard-example">${this.escapeHtml(flashcard.example || flashcard.example_sentence || '')}</div>
-                    <div class="flashcard-mnemonic">
-                        <span class="mnemonic-label">Remember:</span>
-                        ${this.escapeHtml(flashcard.mnemonic || '')}
-                    </div>
-                </div>
-            </div>
-        `;
-
-    card.addEventListener('click', () => {
-      this.flipCard(card);
-      if (typeof this.onCardClick === 'function') {
-        this.onCardClick(flashcard);
-      }
-    });
-
-    return card;
-  }
-
-  flipCard(cardElement) {
-    cardElement.classList.toggle('flipped');
-  }
-
-  escapeHtml(text) {
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-  }
-
-  async exportToAnki() {
-    try {
-      // Filter out invalid flashcards
-      const validFlashcards = this.flashcards.filter((flashcard) => {
-        const targetWord = flashcard.targetWord || flashcard.spanish;
-        return (
-          targetWord &&
-          flashcard.english &&
-          targetWord.trim() !== '' &&
-          flashcard.english.trim() !== ''
-        );
-      });
-
-      if (validFlashcards.length === 0) {
-        alert('No valid flashcards to export');
-        return;
-      }
-
-      // Show loading state
-      const originalText = this.cardCount.textContent;
-      this.cardCount.textContent = 'Exporting...';
-      this.cardCount.style.cursor = 'wait';
-
-      // Get language name for deck naming
-      const languageNames = {
-        es: 'Spanish',
-        ja: 'Japanese',
-        fr: 'French',
-      };
-      const languageName = languageNames[this.currentLanguage] || 'Language';
-
-      const response = await fetch('/api/export-anki', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          flashcards: validFlashcards,
-          deckName: `Aprendemo ${languageName} Cards`,
-          languageCode: this.currentLanguage,
-        }),
-      });
-
-      if (!response.ok) {
-        throw new Error('Export failed');
-      }
-
-      // Create download link
-      const blob = await response.blob();
-      const url = window.URL.createObjectURL(blob);
-      const a = document.createElement('a');
-      a.href = url;
-      a.download = `aprendemo_${this.currentLanguage}_cards.apkg`;
-      document.body.appendChild(a);
-      a.click();
-      document.body.removeChild(a);
-      window.URL.revokeObjectURL(url);
-
-      console.log('ANKI deck exported successfully!');
-
-      // Restore original state
-      this.updateCardCount(this.flashcards.length);
-    } catch (error) {
-      console.error('Error exporting to ANKI:', error);
-      alert('Failed to export flashcards to ANKI');
-
-      // Restore original state
-      this.updateCardCount(this.flashcards.length);
-    }
-  }
-}
diff --git a/frontend/js/ios-audio-workarounds.js b/frontend/js/ios-audio-workarounds.js
deleted file mode 100644
index e195b9c..0000000
--- a/frontend/js/ios-audio-workarounds.js
+++ /dev/null
@@ -1,578 +0,0 @@
-/**
- * iOS Audio Workarounds for WebSocket Audio Streaming
- * Handles iOS-specific audio limitations and provides fallback solutions
- */
-
-class IOSAudioHandler {
-  constructor() {
-    this.isIOS = this.detectIOS();
-    this.audioContext = null;
-    this.audioUnlocked = false;
-    this.microphoneStream = null;
-    this.audioProcessor = null;
-    this.audioChunks = [];
-    this.currentAudioUrl = null;
-    this.audioQueue = [];
-    this.isPlaying = false;
-
-    // iOS-specific audio constraints
-    this.audioConstraints = {
-      audio: {
-        echoCancellation: true,
-        noiseSuppression: true,
-        autoGainControl: true,
-        sampleRate: 16000,
-        channelCount: 1,
-        // iOS-specific constraints
-        latency: 0.02,
-        sampleSize: 16,
-        volume: 1.0,
-      },
-    };
-
-    if (this.isIOS) {
-      console.log('[iOS Audio] iOS device detected, initializing workarounds');
-      this.initializeIOSWorkarounds();
-    }
-  }
-
-  detectIOS() {
-    const userAgent = navigator.userAgent || navigator.vendor || window.opera;
-
-    // Check for iOS devices
-    if (/iPad|iPhone|iPod/.test(userAgent) && !window.MSStream) {
-      return true;
-    }
-
-    // Check for iPad on iOS 13+ (reports as Mac)
-    if (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1) {
-      return true;
-    }
-
-    // Additional check for iOS Safari
-    const isIOSSafari =
-      !!navigator.userAgent.match(/Version\/[\d\.]+.*Safari/) &&
-      /iPad|iPhone|iPod/.test(navigator.userAgent);
-
-    return isIOSSafari;
-  }
-
-  initializeIOSWorkarounds() {
-    // Add touch event listeners for audio unlock
-    this.setupTouchHandlers();
-
-    // Setup visibility change handler to resume audio
-    this.setupVisibilityHandler();
-
-    // Add iOS-specific meta tags if not present
-    this.addIOSMetaTags();
-
-    // Prevent iOS zoom on double-tap
-    this.preventDoubleTapZoom();
-  }
-
-  setupTouchHandlers() {
-    // Unlock audio on first user interaction
-    const unlockAudio = async () => {
-      if (!this.audioUnlocked) {
-        await this.unlockAudioContext();
-        this.audioUnlocked = true;
-        console.log('[iOS Audio] Audio unlocked via user interaction');
-      }
-    };
-
-    // Add multiple event types to catch user interaction
-    ['touchstart', 'touchend', 'click'].forEach((eventType) => {
-      document.addEventListener(eventType, unlockAudio, {
-        once: true,
-        passive: true,
-      });
-    });
-  }
-
-  setupVisibilityHandler() {
-    // Resume audio context when app becomes visible
-    document.addEventListener('visibilitychange', async () => {
-      if (!document.hidden && this.audioContext) {
-        if (this.audioContext.state === 'suspended') {
-          await this.audioContext.resume();
-          console.log(
-            '[iOS Audio] Resumed audio context after visibility change'
-          );
-        }
-      }
-    });
-  }
-
-  addIOSMetaTags() {
-    // Ensure proper viewport settings for iOS
-    let viewport = document.querySelector('meta[name="viewport"]');
-    if (!viewport) {
-      viewport = document.createElement('meta');
-      viewport.name = 'viewport';
-      document.head.appendChild(viewport);
-    }
-    viewport.content =
-      'width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no';
-
-    // Add iOS web app capable meta tag
-    if (!document.querySelector('meta[name="apple-mobile-web-app-capable"]')) {
-      const webAppMeta = document.createElement('meta');
-      webAppMeta.name = 'apple-mobile-web-app-capable';
-      webAppMeta.content = 'yes';
-      document.head.appendChild(webAppMeta);
-    }
-  }
-
-  preventDoubleTapZoom() {
-    let lastTouchEnd = 0;
-    document.addEventListener(
-      'touchend',
-      (event) => {
-        const now = Date.now();
-        if (now - lastTouchEnd <= 300) {
-          event.preventDefault();
-        }
-        lastTouchEnd = now;
-      },
-      false
-    );
-  }
-
-  async unlockAudioContext() {
-    try {
-      // Create or resume audio context
-      if (!this.audioContext) {
-        this.audioContext = new (window.AudioContext ||
-          window.webkitAudioContext)({
-          sampleRate: 16000,
-          latencyHint: 'interactive',
-        });
-      }
-
-      if (this.audioContext.state === 'suspended') {
-        await this.audioContext.resume();
-      }
-
-      // Play a silent buffer to unlock audio
-      const buffer = this.audioContext.createBuffer(1, 1, 22050);
-      const source = this.audioContext.createBufferSource();
-      source.buffer = buffer;
-      source.connect(this.audioContext.destination);
-      source.start(0);
-
-      console.log(
-        '[iOS Audio] AudioContext unlocked, state:',
-        this.audioContext.state
-      );
-
-      // Dispatch custom event to notify app
-      window.dispatchEvent(
-        new CustomEvent('ios-audio-unlocked', {
-          detail: { audioContext: this.audioContext },
-        })
-      );
-
-      return this.audioContext;
-    } catch (error) {
-      console.error('[iOS Audio] Failed to unlock audio context:', error);
-      throw error;
-    }
-  }
-
-  async startMicrophone(onAudioData) {
-    try {
-      console.log('[iOS Audio] Starting microphone...');
-
-      // Ensure audio context is ready
-      if (!this.audioContext || this.audioContext.state === 'suspended') {
-        await this.unlockAudioContext();
-      }
-
-      // Request microphone permission with iOS-optimized constraints
-      this.microphoneStream = await navigator.mediaDevices.getUserMedia(
-        this.audioConstraints
-      );
-      console.log('[iOS Audio] Microphone access granted');
-
-      // Create audio processing pipeline
-      const source = this.audioContext.createMediaStreamSource(
-        this.microphoneStream
-      );
-
-      // Use ScriptProcessorNode for iOS compatibility (AudioWorklet may not work)
-      const bufferSize = 4096;
-      this.audioProcessor = this.audioContext.createScriptProcessor(
-        bufferSize,
-        1,
-        1
-      );
-
-      this.audioProcessor.onaudioprocess = (event) => {
-        const inputData = event.inputBuffer.getChannelData(0);
-
-        // Convert Float32Array to Int16Array
-        const int16Array = new Int16Array(inputData.length);
-        for (let i = 0; i < inputData.length; i++) {
-          const s = Math.max(-1, Math.min(1, inputData[i]));
-          int16Array[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
-        }
-
-        // Convert to base64
-        const base64Audio = this.arrayBufferToBase64(int16Array.buffer);
-
-        // Call the callback with audio data
-        if (onAudioData) {
-          onAudioData(base64Audio);
-        }
-      };
-
-      // Connect the pipeline
-      source.connect(this.audioProcessor);
-      this.audioProcessor.connect(this.audioContext.destination);
-
-      console.log('[iOS Audio] Microphone pipeline connected');
-      return true;
-    } catch (error) {
-      console.error('[iOS Audio] Failed to start microphone:', error);
-
-      // Provide user-friendly error message
-      if (error.name === 'NotAllowedError') {
-        alert(
-          'Microphone access denied. Please enable microphone permissions in Settings > Safari > Microphone.'
-        );
-      } else if (error.name === 'NotFoundError') {
-        alert(
-          'No microphone found. Please ensure your device has a working microphone.'
-        );
-      } else {
-        alert(`Microphone error: ${error.message}`);
-      }
-
-      throw error;
-    }
-  }
-
-  stopMicrophone() {
-    console.log('[iOS Audio] Stopping microphone...');
-
-    if (this.audioProcessor) {
-      this.audioProcessor.disconnect();
-      this.audioProcessor = null;
-    }
-
-    if (this.microphoneStream) {
-      this.microphoneStream.getTracks().forEach((track) => track.stop());
-      this.microphoneStream = null;
-    }
-
-    console.log('[iOS Audio] Microphone stopped');
-  }
-
-  // PCM to WAV conversion for iOS
-  createWAVFromPCM(pcmData, sampleRate = 16000) {
-    // PCM data is Int16Array
-    const numChannels = 1;
-    const bitsPerSample = 16;
-    const dataLength = pcmData.byteLength;
-
-    // Create WAV header
-    const headerLength = 44;
-    const fileLength = headerLength + dataLength;
-    const arrayBuffer = new ArrayBuffer(fileLength);
-    const view = new DataView(arrayBuffer);
-
-    // RIFF header
-    const writeString = (offset, string) => {
-      for (let i = 0; i < string.length; i++) {
-        view.setUint8(offset + i, string.charCodeAt(i));
-      }
-    };
-
-    writeString(0, 'RIFF');
-    view.setUint32(4, fileLength - 8, true); // File size - 8
-    writeString(8, 'WAVE');
-
-    // fmt chunk
-    writeString(12, 'fmt ');
-    view.setUint32(16, 16, true); // fmt chunk size
-    view.setUint16(20, 1, true); // Audio format (1 = PCM)
-    view.setUint16(22, numChannels, true);
-    view.setUint32(24, sampleRate, true);
-    view.setUint32(28, (sampleRate * numChannels * bitsPerSample) / 8, true); // Byte rate
-    view.setUint16(32, (numChannels * bitsPerSample) / 8, true); // Block align
-    view.setUint16(34, bitsPerSample, true);
-
-    // data chunk
-    writeString(36, 'data');
-    view.setUint32(40, dataLength, true);
-
-    // Copy PCM data
-    const dataOffset = 44;
-    const dataView = new Uint8Array(arrayBuffer, dataOffset);
-    dataView.set(new Uint8Array(pcmData.buffer || pcmData));
-
-    return arrayBuffer;
-  }
-
-  // Audio playback methods for iOS
-  async playAudioChunk(base64Audio, isLastChunk = false) {
-    try {
-      // Add chunk to queue
-      this.audioChunks.push(base64Audio);
-
-      // If this is the last chunk or we have enough chunks, create and play audio
-      if (isLastChunk || this.audioChunks.length > 10) {
-        await this.playAccumulatedAudio();
-      }
-    } catch (error) {
-      console.error('[iOS Audio] Failed to play audio chunk:', error);
-    }
-  }
-
-  async playAccumulatedAudio() {
-    if (this.audioChunks.length === 0) return;
-
-    try {
-      console.log(
-        '[iOS Audio] Processing accumulated audio chunks:',
-        this.audioChunks.length
-      );
-
-      // Decode and combine all base64 chunks into one Int16Array
-      let totalLength = 0;
-      const decodedChunks = this.audioChunks.map((base64) => {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-          bytes[i] = binaryString.charCodeAt(i);
-        }
-        totalLength += bytes.length;
-        return bytes;
-      });
-
-      // Combine all chunks
-      const combinedData = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of decodedChunks) {
-        combinedData.set(chunk, offset);
-        offset += chunk.length;
-      }
-
-      // Clear chunks
-      this.audioChunks = [];
-
-      // Convert PCM to WAV
-      const wavData = this.createWAVFromPCM(combinedData, 16000);
-
-      // Create blob with WAV data
-      const audioBlob = new Blob([wavData], { type: 'audio/wav' });
-      const audioUrl = URL.createObjectURL(audioBlob);
-
-      // Clean up previous audio URL
-      if (this.currentAudioUrl) {
-        URL.revokeObjectURL(this.currentAudioUrl);
-      }
-      this.currentAudioUrl = audioUrl;
-
-      // Get audio element - use the one we added to HTML
-      const audioElement =
-        document.getElementById('iosAudioElement') ||
-        document.querySelector('audio');
-
-      if (!audioElement) {
-        console.error('[iOS Audio] No audio element found!');
-        return;
-      }
-
-      // iOS-specific audio element setup
-      audioElement.setAttribute('playsinline', '');
-      audioElement.setAttribute('webkit-playsinline', '');
-      audioElement.preload = 'auto';
-
-      // Add to queue for sequential playback
-      this.audioQueue.push(audioUrl);
-
-      // Start playback if not already playing
-      if (!this.isPlaying) {
-        await this.playNextInQueue(audioElement);
-      }
-    } catch (error) {
-      console.error('[iOS Audio] Failed to play accumulated audio:', error);
-    }
-  }
-
-  async playNextInQueue(audioElement) {
-    if (this.audioQueue.length === 0) {
-      this.isPlaying = false;
-      window.dispatchEvent(new CustomEvent('ios-audio-ended'));
-      return;
-    }
-
-    this.isPlaying = true;
-    const audioUrl = this.audioQueue.shift();
-
-    return new Promise((resolve) => {
-      audioElement.src = audioUrl;
-
-      audioElement.onended = async () => {
-        URL.revokeObjectURL(audioUrl);
-        await this.playNextInQueue(audioElement);
-        resolve();
-      };
-
-      audioElement.onerror = (error) => {
-        console.error('[iOS Audio] Playback error:', error);
-        URL.revokeObjectURL(audioUrl);
-        this.playNextInQueue(audioElement);
-        resolve();
-      };
-
-      // Attempt to play with user gesture handling
-      const playPromise = audioElement.play();
-
-      if (playPromise !== undefined) {
-        playPromise
-          .then(() => {
-            console.log('[iOS Audio] Playback started successfully');
-          })
-          .catch(async (error) => {
-            console.error('[iOS Audio] Playback failed:', error);
-
-            // If playback fails due to user interaction requirement
-            if (error.name === 'NotAllowedError') {
-              // Wait for user interaction
-              console.log(
-                '[iOS Audio] Waiting for user interaction to play audio...'
-              );
-
-              const playOnInteraction = async () => {
-                try {
-                  await audioElement.play();
-                  console.log(
-                    '[iOS Audio] Playback started after user interaction'
-                  );
-                  document.removeEventListener('touchstart', playOnInteraction);
-                  document.removeEventListener('click', playOnInteraction);
-                } catch (e) {
-                  console.error('[iOS Audio] Still cannot play:', e);
-                }
-              };
-
-              document.addEventListener('touchstart', playOnInteraction, {
-                once: true,
-              });
-              document.addEventListener('click', playOnInteraction, {
-                once: true,
-              });
-            }
-          });
-      }
-    });
-  }
-
-  stopAudioPlayback() {
-    console.log('[iOS Audio] Stopping audio playback...');
-
-    // Clear audio queue
-    this.audioQueue = [];
-    this.audioChunks = [];
-    this.isPlaying = false;
-
-    // Stop current audio
-    const audioElement = document.querySelector('audio');
-    if (audioElement) {
-      audioElement.pause();
-      audioElement.src = '';
-    }
-
-    // Clean up audio URLs
-    if (this.currentAudioUrl) {
-      URL.revokeObjectURL(this.currentAudioUrl);
-      this.currentAudioUrl = null;
-    }
-  }
-
-  // Utility methods
-  arrayBufferToBase64(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-
-  base64ToArrayBuffer(base64) {
-    const binaryString = atob(base64);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer;
-  }
-
-  // WebSocket connection helper for iOS
-  getOptimizedWebSocketURL() {
-    const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const hostname = location.hostname;
-    const port = location.port || (protocol === 'wss:' ? '443' : '80');
-
-    // For production
-    if (hostname !== 'localhost' && hostname !== '127.0.0.1') {
-      return `${protocol}//${hostname}:${port}`;
-    }
-
-    // For local development with iOS device
-    // Try to use the computer's local IP address
-    if (this.isIOS && hostname === 'localhost') {
-      // You'll need to replace this with your computer's local IP
-      // Or implement auto-discovery
-      console.warn(
-        '[iOS Audio] Using localhost, consider using computer IP address for iOS testing'
-      );
-    }
-
-    return `${protocol}//${hostname}:8765`;
-  }
-
-  // Enhanced error handling for iOS
-  handleIOSError(error, context) {
-    console.error(`[iOS Audio] Error in ${context}:`, error);
-
-    const errorMessages = {
-      NotAllowedError:
-        'Permission denied. Please allow microphone/audio access.',
-      NotFoundError: 'Required audio hardware not found.',
-      NotReadableError: 'Audio hardware is in use by another application.',
-      OverconstrainedError: 'Audio constraints cannot be satisfied.',
-      SecurityError: 'Audio access blocked due to security settings.',
-      TypeError: 'Invalid audio configuration.',
-    };
-
-    const message =
-      errorMessages[error.name] || `Audio error: ${error.message}`;
-
-    // Dispatch error event for app to handle
-    window.dispatchEvent(
-      new CustomEvent('ios-audio-error', {
-        detail: { error, context, message },
-      })
-    );
-
-    return message;
-  }
-}
-
-// Export for use in main application
-window.IOSAudioHandler = IOSAudioHandler;
-
-// Auto-initialize if on iOS
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', () => {
-    window.iosAudioHandler = new IOSAudioHandler();
-  });
-} else {
-  window.iosAudioHandler = new IOSAudioHandler();
-}
diff --git a/frontend/js/main.js b/frontend/js/main.js
deleted file mode 100644
index 4cfcc8b..0000000
--- a/frontend/js/main.js
+++ /dev/null
@@ -1,923 +0,0 @@
-import { WebSocketClient } from './websocket-client.js';
-import { AudioHandler } from './audio-handler.js';
-import { AudioPlayer } from './audio-player.js';
-import { ChatUI } from './chat-ui.js';
-import { FlashcardUI } from './flashcard-ui.js';
-import { Storage } from './storage.js';
-
-class App {
-  constructor() {
-    this.storage = new Storage();
-    this.wsClient = new WebSocketClient('ws://localhost:3000');
-    this.audioHandler = new AudioHandler();
-    this.audioPlayer = new AudioPlayer();
-    this.chatUI = new ChatUI();
-    this.flashcardUI = new FlashcardUI();
-    this.userId = this.getOrCreateUserId();
-    this.currentAudioElement = null; // Track current Audio element to prevent simultaneous playback
-    this.flashcardUI.onCardClick = (card) => {
-      this.wsClient.send({ type: 'flashcard_clicked', card });
-    };
-
-    // Language state
-    this.currentLanguage = this.storage.getLanguage() || 'es';
-    this.availableLanguages = [];
-
-    this.state = {
-      chatHistory: [],
-      flashcards: [],
-      isRecording: false,
-      connectionStatus: 'connecting',
-      currentTranscript: '',
-      currentLLMResponse: '',
-      pendingTranscription: null,
-      pendingLLMResponse: null,
-      streamingLLMResponse: '',
-      lastPendingTranscription: null,
-      speechDetected: false,
-      llmResponseComplete: false, // Track if LLM response is complete to prevent chunk accumulation
-      currentResponseId: null, // Track current response to match audio with text
-    };
-
-    this.init();
-  }
-
-  async init() {
-    this.loadState();
-    this.setupEventListeners();
-    await this.fetchLanguages();
-    await this.connectWebSocket();
-    await this.initializeAudioPlayer();
-    this.render();
-  }
-
-  async fetchLanguages() {
-    try {
-      const response = await fetch('/api/languages');
-      if (response.ok) {
-        const data = await response.json();
-        this.availableLanguages = data.languages;
-
-        // If current language is not in available languages, use default
-        const isValidLanguage = this.availableLanguages.some(
-          (lang) => lang.code === this.currentLanguage
-        );
-        if (!isValidLanguage) {
-          this.currentLanguage = data.defaultLanguage || 'es';
-        }
-
-        this.populateLanguageDropdown();
-      }
-    } catch (error) {
-      console.error('Failed to fetch languages:', error);
-      // Fallback to default language options
-      this.availableLanguages = [
-        { code: 'es', name: 'Spanish', nativeName: 'Español', flag: '🇲🇽' },
-        { code: 'ja', name: 'Japanese', nativeName: '日本語', flag: '🇯🇵' },
-        { code: 'fr', name: 'French', nativeName: 'Français', flag: '🇫🇷' },
-      ];
-      this.populateLanguageDropdown();
-    }
-  }
-
-  populateLanguageDropdown() {
-    const languageSelect = document.getElementById('languageSelect');
-    if (!languageSelect) return;
-
-    languageSelect.innerHTML = '';
-    this.availableLanguages.forEach((lang) => {
-      const option = document.createElement('option');
-      option.value = lang.code;
-      option.textContent = `${lang.flag} ${lang.name}`;
-      if (lang.code === this.currentLanguage) {
-        option.selected = true;
-      }
-      languageSelect.appendChild(option);
-    });
-
-    languageSelect.disabled = false;
-  }
-
-  async initializeAudioPlayer() {
-    try {
-      await this.audioPlayer.initialize();
-      console.log('Audio player initialized');
-    } catch (error) {
-      console.error('Failed to initialize audio player:', error);
-    }
-  }
-
-  loadState() {
-    const savedState = this.storage.getState();
-    if (savedState) {
-      this.state.chatHistory = savedState.chatHistory || [];
-    }
-
-    // Load flashcards from storage (for current language)
-    this.state.flashcards = this.storage.getFlashcards(this.currentLanguage);
-
-    // Load existing conversation history
-    const existingConversation = this.storage.getConversationHistory();
-    console.log(
-      'Loading existing conversation history:',
-      existingConversation.messages.length,
-      'messages'
-    );
-    console.log(
-      'Loading existing flashcards:',
-      this.state.flashcards.length,
-      'flashcards'
-    );
-  }
-
-  saveState() {
-    this.storage.saveState({
-      chatHistory: this.state.chatHistory,
-    });
-    // Flashcards are saved separately through storage.addFlashcards()
-  }
-
-  setupEventListeners() {
-    const micButton = document.getElementById('micButton');
-    const restartButton = document.getElementById('restartButton');
-    const languageSelect = document.getElementById('languageSelect');
-
-    // Check for iOS
-    const isIOS =
-      /iPad|iPhone|iPod/.test(navigator.userAgent) ||
-      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
-
-    // Add both click and touch events for better iOS support
-    micButton.addEventListener('click', (e) => {
-      e.preventDefault();
-      this.toggleStreaming();
-    });
-
-    if (isIOS) {
-      // Add touch event for iOS
-      micButton.addEventListener(
-        'touchend',
-        (e) => {
-          e.preventDefault();
-          this.toggleStreaming();
-        },
-        { passive: false }
-      );
-
-      // Prevent double-tap zoom on mic button
-      let lastTouchEnd = 0;
-      micButton.addEventListener(
-        'touchend',
-        (e) => {
-          const now = Date.now();
-          if (now - lastTouchEnd <= 300) {
-            e.preventDefault();
-          }
-          lastTouchEnd = now;
-        },
-        false
-      );
-    }
-
-    // Restart button event listener
-    restartButton.addEventListener('click', (e) => {
-      e.preventDefault();
-      this.restartConversation();
-    });
-
-    if (isIOS) {
-      restartButton.addEventListener(
-        'touchend',
-        (e) => {
-          e.preventDefault();
-          this.restartConversation();
-        },
-        { passive: false }
-      );
-    }
-
-    // Language selector event listener
-    languageSelect.addEventListener('change', (e) => {
-      const newLanguage = e.target.value;
-      if (newLanguage !== this.currentLanguage) {
-        this.changeLanguage(newLanguage);
-      }
-    });
-
-    this.wsClient.on('connection', (status) => {
-      this.state.connectionStatus = status;
-
-      // Send existing conversation history to backend when connected
-      if (status === 'connected') {
-        // Send language preference first
-        this.wsClient.send({
-          type: 'set_language',
-          languageCode: this.currentLanguage,
-        });
-
-        const existingConversation = this.storage.getConversationHistory();
-        if (existingConversation.messages.length > 0) {
-          console.log(
-            'Sending existing conversation history to backend:',
-            existingConversation.messages.length,
-            'messages'
-          );
-          this.wsClient.send({
-            type: 'conversation_update',
-            data: existingConversation,
-          });
-        }
-      }
-
-      this.render();
-    });
-
-    this.wsClient.on('transcript_update', (text) => {
-      this.state.currentTranscript = text;
-      this.state.speechDetected = true; // Ensure speech detected is true when we get transcript
-      this.render();
-    });
-
-    this.wsClient.on('ai_response', (response) => {
-      this.addMessage('teacher', response.text);
-      this.state.currentTranscript = '';
-      this.state.speechDetected = false;
-      // Note: ai_response is legacy - audio should come via audio_stream now
-      // But if it does come, stop any current playback first
-      if (response.audio) {
-        this.audioPlayer.stop();
-        // Convert WAV base64 to PCM and play through AudioPlayer
-        // For now, use the legacy playAudio but stop current playback first
-        this.playAudio(response.audio);
-      }
-    });
-
-    this.wsClient.on('flashcard_generated', (flashcard) => {
-      this.addFlashcard(flashcard);
-    });
-
-    this.wsClient.on('flashcards_generated', (flashcards) => {
-      console.log('Received new flashcards:', flashcards);
-      this.addMultipleFlashcards(flashcards);
-    });
-
-    this.wsClient.on('speech_detected', (data) => {
-      // Show listening indicator immediately when VAD detects speech
-      // Use empty string or placeholder - transcript will update as it arrives
-      this.state.currentTranscript = data.text || '';
-      this.state.speechDetected = true;
-
-      // Trigger interrupt behavior immediately on VAD detection
-      // This freezes the current response if one is streaming
-      this.handleInterrupt();
-
-      this.render();
-    });
-
-    this.wsClient.on('partial_transcript', (data) => {
-      // Update the transcript in real-time as AssemblyAI processes speech
-      if (data.text) {
-        this.state.currentTranscript = data.text;
-        this.state.speechDetected = true;
-        this.render();
-      }
-    });
-
-    this.wsClient.on('speech_ended', (data) => {
-      // VAD stopped detecting speech - clear the real-time transcript bubble
-      console.log(
-        '[Main] VAD stopped detecting speech, clearing real-time transcript'
-      );
-
-      // Clear speech detected state to hide the real-time transcript bubble
-      // Only clear if we don't have a pending transcription (which means speech was processed)
-      // If we have a pending transcription, it will be handled by the transcription handler
-      if (!this.state.pendingTranscription) {
-        this.state.currentTranscript = '';
-        this.state.speechDetected = false;
-        this.render();
-      }
-    });
-
-    this.wsClient.on('transcription', (data) => {
-      // Stop any ongoing audio from previous response to prevent audio/text mismatch
-      // A new transcription means a new conversation turn is starting
-      this.audioPlayer.stop();
-      if (this.currentAudioElement) {
-        this.currentAudioElement.pause();
-        this.currentAudioElement.src = '';
-        this.currentAudioElement = null;
-      }
-
-      this.state.pendingTranscription = data.text;
-      this.state.currentTranscript = '';
-      this.state.speechDetected = false; // Clear speech detected when transcription is complete
-
-      // If we have a frozen LLM response from an interrupt, finalize it now
-      if (this.state.pendingLLMResponse && !this.state.streamingLLMResponse) {
-        // We have a frozen response from an interrupt, finalize it with this transcription
-        console.log(
-          '[Main] Finalizing frozen LLM response with new transcription'
-        );
-        this.checkAndUpdateConversation();
-      }
-
-      // Before resetting LLM streaming, finalize any pending LLM response
-      // This ensures the text is added to history even if typewriter was interrupted
-      if (
-        this.state.streamingLLMResponse &&
-        this.state.streamingLLMResponse.trim() &&
-        this.state.llmResponseComplete &&
-        !this.state.pendingLLMResponse
-      ) {
-        console.log(
-          '[Main] Finalizing LLM response before clearing streaming state'
-        );
-        this.state.pendingLLMResponse = this.state.streamingLLMResponse;
-        this.checkAndUpdateConversation();
-      }
-
-      // Reset LLM streaming for new conversation turn
-      this.state.streamingLLMResponse = ''; // Reset LLM streaming for new conversation
-      this.state.llmResponseComplete = false; // Reset completion flag for new response
-      this.state.currentResponseId = null; // Reset response ID
-
-      // Only render if the transcription changed to avoid restarting typewriter
-      if (this.state.lastPendingTranscription !== data.text) {
-        this.state.lastPendingTranscription = data.text;
-        this.render();
-      }
-
-      // Check if we can update conversation (will happen if we just finalized a frozen response)
-      this.checkAndUpdateConversation();
-    });
-
-    this.wsClient.on('llm_response_chunk', (data) => {
-      // Only accumulate chunks if response is not yet complete
-      // This prevents chunks from being added after llm_response_complete
-      if (!this.state.llmResponseComplete) {
-        this.state.streamingLLMResponse += data.text;
-      } else {
-        console.warn(
-          '[Main] Ignoring llm_response_chunk after response complete'
-        );
-      }
-    });
-
-    this.wsClient.on('llm_response_complete', (data) => {
-      console.log(
-        '[Main] LLM response complete, starting typewriter with:',
-        data.text
-      );
-
-      // Generate a unique ID for this response to match audio with text
-      const responseId = `response_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-      this.state.currentResponseId = responseId;
-
-      // Mark response as complete to prevent further chunk accumulation
-      this.state.llmResponseComplete = true;
-
-      // Use the provided text (which should be the complete response)
-      // This ensures we use the backend's final text, not accumulated chunks
-      const finalText = data.text || this.state.streamingLLMResponse;
-      this.state.streamingLLMResponse = finalText;
-
-      console.log('[Main] About to render for typewriter effect');
-
-      // Set up callback for when typewriter finishes
-      this.chatUI.setLLMTypewriterCallback(() => {
-        console.log('[Main] LLM typewriter finished, updating conversation');
-        // Only update if this is still the current response (not interrupted)
-        if (this.state.currentResponseId === responseId) {
-          this.state.pendingLLMResponse = finalText;
-          this.checkAndUpdateConversation();
-        } else {
-          console.log(
-            '[Main] Response was interrupted, skipping conversation update'
-          );
-        }
-      });
-
-      this.render(); // Start typewriter effect
-    });
-
-    this.wsClient.on('audio_stream', (data) => {
-      this.handleAudioStream(data);
-    });
-
-    this.wsClient.on('audio_stream_complete', (data) => {
-      console.log('Audio stream complete signal received');
-      this.audioPlayer.markStreamComplete();
-    });
-
-    // Interrupt handling: stop audio playback and freeze current response
-    // This is triggered both by 'interrupt' message and 'speech_detected' (VAD)
-    this.wsClient.on('interrupt', (_data) => {
-      console.log('[Main] Interrupt message received');
-      this.handleInterrupt();
-    });
-
-    // Handle language change confirmation from backend
-    this.wsClient.on('language_changed', (data) => {
-      console.log(`[Main] Language changed to ${data.languageName}`);
-      // Optionally show a notification or update UI
-    });
-
-    this.audioHandler.on('audioChunk', (audioData) => {
-      this.wsClient.sendAudioChunk(audioData);
-    });
-
-    this.audioPlayer.on('playback_started', () => {
-      console.log('Audio playback started');
-    });
-
-    this.audioPlayer.on('playback_finished', () => {
-      console.log('Audio playback finished');
-    });
-  }
-
-  async changeLanguage(newLanguage) {
-    console.log(`[Main] Changing language from ${this.currentLanguage} to ${newLanguage}`);
-
-    // Stop any ongoing recording
-    if (this.state.isRecording) {
-      this.audioHandler.stopStreaming();
-      this.state.isRecording = false;
-    }
-
-    // Stop audio playback
-    try {
-      this.audioPlayer.stop();
-    } catch (error) {
-      console.error('Error stopping audio:', error);
-    }
-
-    // Update language
-    this.currentLanguage = newLanguage;
-    this.storage.saveLanguage(newLanguage);
-
-    // Clear conversation for new language
-    this.storage.clearConversation();
-    this.state.chatHistory = [];
-    this.state.currentTranscript = '';
-    this.state.currentLLMResponse = '';
-    this.state.pendingTranscription = null;
-    this.state.pendingLLMResponse = null;
-    this.state.streamingLLMResponse = '';
-    this.state.lastPendingTranscription = null;
-    this.state.speechDetected = false;
-    this.state.llmResponseComplete = false;
-    this.state.currentResponseId = null;
-
-    // Clear typewriters
-    this.chatUI.clearAllTypewriters();
-
-    // Load flashcards for new language
-    this.state.flashcards = this.storage.getFlashcards(newLanguage);
-
-    // Send language change to backend
-    if (this.wsClient && this.state.connectionStatus === 'connected') {
-      this.wsClient.send({
-        type: 'set_language',
-        languageCode: newLanguage,
-      });
-    }
-
-    // Re-render UI
-    this.render();
-  }
-
-  async connectWebSocket() {
-    try {
-      await this.wsClient.connect();
-      // After connection, send lightweight user context (timezone)
-      try {
-        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone || '';
-        this.wsClient.send({
-          type: 'user_context',
-          timezone: tz,
-          userId: this.userId,
-          languageCode: this.currentLanguage,
-        });
-      } catch (e) {
-        // ignore
-      }
-    } catch (error) {
-      console.error('WebSocket connection failed:', error);
-      this.state.connectionStatus = 'disconnected';
-      this.render();
-    }
-  }
-
-  getOrCreateUserId() {
-    try {
-      const key = 'aprende-user-id';
-      let id = localStorage.getItem(key);
-      if (!id) {
-        id =
-          typeof crypto !== 'undefined' && crypto.randomUUID
-            ? crypto.randomUUID()
-            : `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-        localStorage.setItem(key, id);
-      }
-      return id;
-    } catch (_) {
-      return `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-    }
-  }
-
-  async toggleStreaming() {
-    if (!this.state.isRecording) {
-      try {
-        await this.audioHandler.startStreaming();
-        this.state.isRecording = true;
-        this.state.currentTranscript = '';
-        this.state.speechDetected = false;
-      } catch (error) {
-        console.error('Failed to start streaming:', error);
-        alert(
-          'Microphone access denied. Please enable microphone permissions.'
-        );
-        return;
-      }
-    } else {
-      this.audioHandler.stopStreaming();
-      this.state.isRecording = false;
-      this.state.currentTranscript = '';
-      this.state.speechDetected = false;
-    }
-    this.render();
-  }
-
-  restartConversation() {
-    // Stop any ongoing recording
-    if (this.state.isRecording) {
-      this.audioHandler.stopStreaming();
-      this.state.isRecording = false;
-    }
-
-    // Stop audio playback
-    try {
-      this.audioPlayer.stop();
-    } catch (error) {
-      console.error('Error stopping audio:', error);
-    }
-
-    // Clear conversation history from storage
-    this.storage.clearConversation();
-
-    // Clear chat history from state
-    this.state.chatHistory = [];
-    this.state.currentTranscript = '';
-    this.state.currentLLMResponse = '';
-    this.state.pendingTranscription = null;
-    this.state.pendingLLMResponse = null;
-    this.state.streamingLLMResponse = '';
-    this.state.lastPendingTranscription = null;
-    this.state.speechDetected = false;
-    this.state.llmResponseComplete = false;
-    this.state.currentResponseId = null;
-
-    // Clear typewriters
-    this.chatUI.clearAllTypewriters();
-
-    // Save cleared state
-    this.saveState();
-
-    // Send restart message to backend
-    if (this.wsClient && this.state.connectionStatus === 'connected') {
-      this.wsClient.send({
-        type: 'restart_conversation',
-      });
-    }
-
-    // Re-render UI
-    this.render();
-  }
-
-  checkAndUpdateConversation() {
-    // Only proceed when we have both transcription and LLM response
-    console.log(
-      'checkAndUpdateConversation called - pending transcription:',
-      this.state.pendingTranscription,
-      'pending LLM:',
-      this.state.pendingLLMResponse
-    );
-
-    if (this.state.pendingTranscription && this.state.pendingLLMResponse) {
-      // Check if we've already added both messages together to prevent duplicates
-      const lastUserMessage = this.state.chatHistory
-        .filter((m) => m.role === 'learner')
-        .pop();
-      const lastTeacherMessage = this.state.chatHistory
-        .filter((m) => m.role === 'teacher')
-        .pop();
-
-      // Check if both messages together are duplicates
-      const isDuplicate =
-        lastUserMessage?.content === this.state.pendingTranscription &&
-        lastTeacherMessage?.content === this.state.pendingLLMResponse;
-
-      if (isDuplicate) {
-        console.log(
-          '[Main] Duplicate conversation turn detected, skipping update'
-        );
-        // Still clear the pending state
-        this.state.pendingTranscription = null;
-        this.state.pendingLLMResponse = null;
-        this.state.streamingLLMResponse = '';
-        this.state.lastPendingTranscription = null;
-        this.state.llmResponseComplete = false;
-        return;
-      }
-
-      // Check if teacher message was already added (from interrupt) but user message wasn't
-      // In this case, we just need to add the user message
-      const teacherAlreadyAdded =
-        lastTeacherMessage?.content === this.state.pendingLLMResponse;
-      const userAlreadyAdded =
-        lastUserMessage?.content === this.state.pendingTranscription;
-
-      if (teacherAlreadyAdded && !userAlreadyAdded) {
-        console.log(
-          '[Main] Teacher message already added from interrupt, adding user message'
-        );
-        // Just add the user message
-        this.storage.addMessage('user', this.state.pendingTranscription);
-        this.addMessageToHistory('learner', this.state.pendingTranscription);
-
-        // Send conversation update
-        const conversationHistory = this.storage.getConversationHistory();
-        this.wsClient.send({
-          type: 'conversation_update',
-          data: conversationHistory,
-        });
-
-        // Clear pending state
-        this.state.pendingTranscription = null;
-        this.state.pendingLLMResponse = null;
-        this.state.streamingLLMResponse = '';
-        this.state.lastPendingTranscription = null;
-        this.state.llmResponseComplete = false;
-        this.state.currentResponseId = null;
-
-        this.render();
-        return;
-      }
-
-      console.log('Adding messages to conversation history...');
-
-      // Add both messages to conversation history (with automatic truncation)
-      const userHistory = this.storage.addMessage(
-        'user',
-        this.state.pendingTranscription
-      );
-      const assistantHistory = this.storage.addMessage(
-        'assistant',
-        this.state.pendingLLMResponse
-      );
-
-      console.log(
-        'User message added, total messages:',
-        userHistory.messages.length
-      );
-      console.log(
-        'Assistant message added, total messages:',
-        assistantHistory.messages.length
-      );
-
-      // Add to chat history for display
-      this.addMessageToHistory('learner', this.state.pendingTranscription);
-      this.addMessageToHistory('teacher', this.state.pendingLLMResponse);
-
-      // Get updated conversation history and send to backend
-      const conversationHistory = this.storage.getConversationHistory();
-      console.log(
-        'Sending conversation update to backend:',
-        conversationHistory.messages.length,
-        'messages'
-      );
-
-      this.wsClient.send({
-        type: 'conversation_update',
-        data: conversationHistory,
-      });
-
-      // Clear pending messages and streaming state
-      this.state.pendingTranscription = null;
-      this.state.pendingLLMResponse = null;
-      this.state.streamingLLMResponse = '';
-      this.state.lastPendingTranscription = null;
-      this.state.llmResponseComplete = false;
-      this.state.currentResponseId = null;
-
-      // Clear any active typewriters before rendering final state
-      this.chatUI.clearAllTypewriters();
-      this.render();
-    }
-  }
-
-  addMessage(role, content) {
-    // This method is kept for backward compatibility with existing addMessage calls
-    this.addMessageToHistory(role, content);
-  }
-
-  addMessageToHistory(role, content) {
-    const message = { role, content };
-    this.state.chatHistory.push(message);
-    this.saveState();
-    this.render();
-  }
-
-  addFlashcard(flashcard) {
-    // Use targetWord for deduplication (backwards compatible with spanish)
-    const targetWord = flashcard.targetWord || flashcard.spanish || flashcard.word;
-    const exists = this.state.flashcards.some((card) => {
-      const cardWord = card.targetWord || card.spanish || card.word;
-      return cardWord === targetWord;
-    });
-
-    if (!exists) {
-      this.state.flashcards.push(flashcard);
-      this.storage.addFlashcards([flashcard], this.currentLanguage);
-      this.saveState();
-      this.render();
-    }
-  }
-
-  addMultipleFlashcards(flashcards) {
-    // Use storage method which handles deduplication and persistence
-    const updatedFlashcards = this.storage.addFlashcards(flashcards, this.currentLanguage);
-    this.state.flashcards = updatedFlashcards;
-    this.saveState();
-    this.render();
-  }
-
-  getContextForBackend() {
-    return {
-      chatHistory: this.state.chatHistory.slice(-10),
-      flashcards: this.state.flashcards,
-    };
-  }
-
-  handleInterrupt() {
-    console.log(
-      '[Main] Handling interrupt - stopping audio and freezing current response'
-    );
-    try {
-      // Stop audio playback
-      this.audioPlayer.stop();
-      // Also stop any Audio element playback
-      if (this.currentAudioElement) {
-        this.currentAudioElement.pause();
-        this.currentAudioElement.src = '';
-        this.currentAudioElement = null;
-      }
-
-      // Freeze the current LLM response if there is one
-      // This means finalizing it and adding it to chat history, but keeping it visible
-      if (
-        this.state.streamingLLMResponse &&
-        this.state.streamingLLMResponse.trim()
-      ) {
-        console.log(
-          '[Main] Freezing current LLM response:',
-          this.state.streamingLLMResponse
-        );
-
-        // Stop typewriter effect immediately
-        this.chatUI.clearAllTypewriters();
-
-        // Get the frozen text
-        const frozenText = this.state.streamingLLMResponse;
-
-        // Save the frozen response
-        this.state.pendingLLMResponse = frozenText;
-
-        // If we have a pending transcription, finalize the conversation turn now
-        // Otherwise, we'll finalize it when the transcription arrives
-        if (this.state.pendingTranscription) {
-          // We have both, so we can finalize this conversation turn immediately
-          // This adds both messages to chat history
-          this.checkAndUpdateConversation();
-        } else {
-          // No transcription yet - add just the LLM response to chat history now
-          // so it stays visible. We'll add the user message when transcription arrives.
-          // Check if this message is already in history to avoid duplicates
-          const lastTeacherMessage = this.state.chatHistory
-            .filter((m) => m.role === 'teacher')
-            .pop();
-
-          if (lastTeacherMessage?.content !== frozenText) {
-            console.log('[Main] Adding frozen LLM response to chat history');
-            this.addMessageToHistory('teacher', frozenText);
-          }
-        }
-
-        // Clear streaming state - this will remove the streaming element
-        // But the message is now in chat history, so it will stay visible
-        this.state.streamingLLMResponse = '';
-        this.state.llmResponseComplete = false;
-        this.state.currentResponseId = null;
-      } else {
-        // No streaming response, just clear state
-        this.state.streamingLLMResponse = '';
-        this.state.llmResponseComplete = false;
-        this.state.currentResponseId = null;
-      }
-
-      // Render to update UI
-      this.render();
-    } catch (error) {
-      console.warn('Error handling interrupt:', error);
-    }
-  }
-
-  async handleAudioStream(data) {
-    try {
-      if (data.audio && data.audio.length > 0) {
-        console.log(
-          `Received audio stream: ${data.audio.length} bytes at ${data.sampleRate}Hz [format:${data.audioFormat}]${data.text ? ` with text: "${data.text}"` : ''}`
-        );
-        await this.audioPlayer.addAudioStream(data.audio, data.sampleRate, false, data.audioFormat);
-      }
-    } catch (error) {
-      console.error('Error handling audio stream:', error);
-    }
-  }
-
-  playAudio(audioData) {
-    // Stop any current AudioPlayer playback to prevent simultaneous audio
-    this.audioPlayer.stop();
-
-    // Stop any existing Audio element playback
-    if (this.currentAudioElement) {
-      try {
-        this.currentAudioElement.pause();
-        this.currentAudioElement.src = '';
-        this.currentAudioElement = null;
-      } catch (error) {
-        console.warn('Error stopping previous audio element:', error);
-      }
-    }
-
-    const audio = new Audio();
-    this.currentAudioElement = audio;
-    audio.src = `data:audio/wav;base64,${audioData}`;
-    audio.play().catch(console.error);
-
-    // Clean up when audio finishes
-    audio.onended = () => {
-      if (this.currentAudioElement === audio) {
-        this.currentAudioElement = null;
-      }
-    };
-
-    audio.onerror = () => {
-      if (this.currentAudioElement === audio) {
-        this.currentAudioElement = null;
-      }
-    };
-  }
-
-  render() {
-    this.updateConnectionStatus();
-    this.chatUI.render(
-      this.state.chatHistory,
-      this.state.currentTranscript,
-      this.state.currentLLMResponse,
-      this.state.pendingTranscription,
-      this.state.streamingLLMResponse,
-      this.state.isRecording,
-      this.state.speechDetected
-    );
-    this.flashcardUI.render(this.state.flashcards, this.currentLanguage);
-
-    const micButton = document.getElementById('micButton');
-    const restartButton = document.getElementById('restartButton');
-    const languageSelect = document.getElementById('languageSelect');
-
-    micButton.disabled = this.state.connectionStatus !== 'connected';
-    micButton.classList.toggle('recording', this.state.isRecording);
-    restartButton.disabled = this.state.connectionStatus !== 'connected';
-    languageSelect.disabled = this.state.connectionStatus !== 'connected';
-  }
-
-  updateConnectionStatus() {
-    const statusDot = document.getElementById('statusDot');
-    const statusText = document.getElementById('statusText');
-
-    statusDot.className = `status-dot ${this.state.connectionStatus}`;
-
-    const statusMessages = {
-      connecting: 'Connecting...',
-      connected: 'Connected',
-      disconnected: 'Disconnected',
-    };
-
-    statusText.textContent =
-      statusMessages[this.state.connectionStatus] || 'Unknown';
-  }
-}
-
-new App();
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
new file mode 100644
index 0000000..805265b
--- /dev/null
+++ b/frontend/package-lock.json
@@ -0,0 +1,3212 @@
+{
+  "name": "frontend",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "frontend",
+      "version": "0.0.0",
+      "dependencies": {
+        "react": "^19.2.0",
+        "react-dom": "^19.2.0"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.39.1",
+        "@types/node": "^24.10.1",
+        "@types/react": "^19.2.5",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^5.1.1",
+        "eslint": "^9.39.1",
+        "eslint-plugin-react-hooks": "^7.0.1",
+        "eslint-plugin-react-refresh": "^0.4.24",
+        "globals": "^16.5.0",
+        "typescript": "~5.9.3",
+        "typescript-eslint": "^8.46.4",
+        "vite": "^7.2.4"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz",
+      "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
+      "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.5",
+        "@babel/helper-compilation-targets": "^7.27.2",
+        "@babel/helper-module-transforms": "^7.28.3",
+        "@babel/helpers": "^7.28.4",
+        "@babel/parser": "^7.28.5",
+        "@babel/template": "^7.27.2",
+        "@babel/traverse": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz",
+      "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.27.2",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.3",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
+      "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/traverse": "^7.28.3"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
+      "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.4"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
+      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.5"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/parser": "^7.27.2",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz",
+      "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.5",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.28.5",
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.5",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
+      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
+      "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz",
+      "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz",
+      "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz",
+      "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
+      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz",
+      "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz",
+      "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz",
+      "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz",
+      "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz",
+      "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz",
+      "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz",
+      "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz",
+      "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz",
+      "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz",
+      "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz",
+      "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz",
+      "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz",
+      "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz",
+      "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz",
+      "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz",
+      "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
+      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.1",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
+      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz",
+      "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.2",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz",
+      "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.53",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.53.tgz",
+      "integrity": "sha512-vENRlFU4YbrwVqNDZ7fLvy+JR1CRkyr01jhSiDpE1u6py3OMzQfztQU2jxykW3ALNxO4kSlqIDeYyD0Y9RcQeQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.54.0.tgz",
+      "integrity": "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.54.0.tgz",
+      "integrity": "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.54.0.tgz",
+      "integrity": "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.54.0.tgz",
+      "integrity": "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.54.0.tgz",
+      "integrity": "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.54.0.tgz",
+      "integrity": "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.54.0.tgz",
+      "integrity": "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.54.0.tgz",
+      "integrity": "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.54.0.tgz",
+      "integrity": "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.54.0.tgz",
+      "integrity": "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.54.0.tgz",
+      "integrity": "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.54.0.tgz",
+      "integrity": "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.54.0.tgz",
+      "integrity": "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.54.0.tgz",
+      "integrity": "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.54.0.tgz",
+      "integrity": "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.54.0.tgz",
+      "integrity": "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.54.0.tgz",
+      "integrity": "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.54.0.tgz",
+      "integrity": "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.54.0.tgz",
+      "integrity": "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.54.0.tgz",
+      "integrity": "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.10.4",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.4.tgz",
+      "integrity": "sha512-vnDVpYPMzs4wunl27jHrfmwojOGKya0xyM3sH+UE5iv5uPS6vX7UIoh6m+vQc5LGBq52HBKPIn/zcSZVzeDEZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.7.tgz",
+      "integrity": "sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.51.0.tgz",
+      "integrity": "sha512-XtssGWJvypyM2ytBnSnKtHYOGT+4ZwTnBVl36TA4nRO2f4PRNGz5/1OszHzcZCvcBMh+qb7I06uoCmLTRdR9og==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.10.0",
+        "@typescript-eslint/scope-manager": "8.51.0",
+        "@typescript-eslint/type-utils": "8.51.0",
+        "@typescript-eslint/utils": "8.51.0",
+        "@typescript-eslint/visitor-keys": "8.51.0",
+        "ignore": "^7.0.0",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.51.0",
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.51.0.tgz",
+      "integrity": "sha512-3xP4XzzDNQOIqBMWogftkwxhg5oMKApqY0BAflmLZiFYHqyhSOxv/cd/zPQLTcCXr4AkaKb25joocY0BD1WC6A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.51.0",
+        "@typescript-eslint/types": "8.51.0",
+        "@typescript-eslint/typescript-estree": "8.51.0",
+        "@typescript-eslint/visitor-keys": "8.51.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.51.0.tgz",
+      "integrity": "sha512-Luv/GafO07Z7HpiI7qeEW5NW8HUtZI/fo/kE0YbtQEFpJRUuR0ajcWfCE5bnMvL7QQFrmT/odMe8QZww8X2nfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.51.0",
+        "@typescript-eslint/types": "^8.51.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.51.0.tgz",
+      "integrity": "sha512-JhhJDVwsSx4hiOEQPeajGhCWgBMBwVkxC/Pet53EpBVs7zHHtayKefw1jtPaNRXpI9RA2uocdmpdfE7T+NrizA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.51.0",
+        "@typescript-eslint/visitor-keys": "8.51.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.51.0.tgz",
+      "integrity": "sha512-Qi5bSy/vuHeWyir2C8u/uqGMIlIDu8fuiYWv48ZGlZ/k+PRPHtaAu7erpc7p5bzw2WNNSniuxoMSO4Ar6V9OXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.51.0.tgz",
+      "integrity": "sha512-0XVtYzxnobc9K0VU7wRWg1yiUrw4oQzexCG2V2IDxxCxhqBMSMbjB+6o91A+Uc0GWtgjCa3Y8bi7hwI0Tu4n5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.51.0",
+        "@typescript-eslint/typescript-estree": "8.51.0",
+        "@typescript-eslint/utils": "8.51.0",
+        "debug": "^4.3.4",
+        "ts-api-utils": "^2.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.51.0.tgz",
+      "integrity": "sha512-TizAvWYFM6sSscmEakjY3sPqGwxZRSywSsPEiuZF6d5GmGD9Gvlsv0f6N8FvAAA0CD06l3rIcWNbsN1e5F/9Ag==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.51.0.tgz",
+      "integrity": "sha512-1qNjGqFRmlq0VW5iVlcyHBbCjPB7y6SxpBkrbhNWMy/65ZoncXCEPJxkRZL8McrseNH6lFhaxCIaX+vBuFnRng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.51.0",
+        "@typescript-eslint/tsconfig-utils": "8.51.0",
+        "@typescript-eslint/types": "8.51.0",
+        "@typescript-eslint/visitor-keys": "8.51.0",
+        "debug": "^4.3.4",
+        "minimatch": "^9.0.4",
+        "semver": "^7.6.0",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.51.0.tgz",
+      "integrity": "sha512-11rZYxSe0zabiKaCP2QAwRf/dnmgFgvTmeDTtZvUvXG3UuAdg/GU02NExmmIXzz3vLGgMdtrIosI84jITQOxUA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.7.0",
+        "@typescript-eslint/scope-manager": "8.51.0",
+        "@typescript-eslint/types": "8.51.0",
+        "@typescript-eslint/typescript-estree": "8.51.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.51.0.tgz",
+      "integrity": "sha512-mM/JRQOzhVN1ykejrvwnBRV3+7yTKK8tVANVN3o1O0t0v7o+jqdVu9crPy5Y9dov15TJk/FTIgoUGHrTOVL3Zg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.51.0",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.2.tgz",
+      "integrity": "sha512-EcA07pHJouywpzsoTUqNh5NwGayl2PPVEJKUSinGGSxFGYn+shYbqMGBg6FXDqgXum9Ou/ecb+411ssw8HImJQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.5",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.53",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.18.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.9.11",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.11.tgz",
+      "integrity": "sha512-Sg0xJUNDU1sJNGdfGWhVHX0kkZ+HWcvmVymJbj6NSgZZmW/8S9Y2HQ5euytnIgakgxN6papOAWiwDo1ctFDcoQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.js"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001762",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001762.tgz",
+      "integrity": "sha512-PxZwGNvH7Ak8WX5iXzoK1KPZttBXNPuaOvI2ZYU7NrlM+d9Ov+TUvlLOBNGzVXAntMSMMlJPd+jY6ovrVjSmUw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.267",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz",
+      "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
+      "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.2",
+        "@esbuild/android-arm": "0.27.2",
+        "@esbuild/android-arm64": "0.27.2",
+        "@esbuild/android-x64": "0.27.2",
+        "@esbuild/darwin-arm64": "0.27.2",
+        "@esbuild/darwin-x64": "0.27.2",
+        "@esbuild/freebsd-arm64": "0.27.2",
+        "@esbuild/freebsd-x64": "0.27.2",
+        "@esbuild/linux-arm": "0.27.2",
+        "@esbuild/linux-arm64": "0.27.2",
+        "@esbuild/linux-ia32": "0.27.2",
+        "@esbuild/linux-loong64": "0.27.2",
+        "@esbuild/linux-mips64el": "0.27.2",
+        "@esbuild/linux-ppc64": "0.27.2",
+        "@esbuild/linux-riscv64": "0.27.2",
+        "@esbuild/linux-s390x": "0.27.2",
+        "@esbuild/linux-x64": "0.27.2",
+        "@esbuild/netbsd-arm64": "0.27.2",
+        "@esbuild/netbsd-x64": "0.27.2",
+        "@esbuild/openbsd-arm64": "0.27.2",
+        "@esbuild/openbsd-x64": "0.27.2",
+        "@esbuild/openharmony-arm64": "0.27.2",
+        "@esbuild/sunos-x64": "0.27.2",
+        "@esbuild/win32-arm64": "0.27.2",
+        "@esbuild/win32-ia32": "0.27.2",
+        "@esbuild/win32-x64": "0.27.2"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.39.2",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz",
+      "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.1",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.1",
+        "@eslint/js": "9.39.2",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
+      "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "hermes-parser": "^0.25.1",
+        "zod": "^3.25.0 || ^4.0.0",
+        "zod-validation-error": "^3.5.0 || ^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.4.26",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz",
+      "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": ">=8.40"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",
+      "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hermes-estree": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
+      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/hermes-parser": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
+      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hermes-estree": "0.25.1"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.27",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
+      "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.3"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
+      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.54.0.tgz",
+      "integrity": "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.54.0",
+        "@rollup/rollup-android-arm64": "4.54.0",
+        "@rollup/rollup-darwin-arm64": "4.54.0",
+        "@rollup/rollup-darwin-x64": "4.54.0",
+        "@rollup/rollup-freebsd-arm64": "4.54.0",
+        "@rollup/rollup-freebsd-x64": "4.54.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.54.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.54.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.54.0",
+        "@rollup/rollup-linux-arm64-musl": "4.54.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.54.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.54.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-musl": "4.54.0",
+        "@rollup/rollup-openharmony-arm64": "4.54.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.54.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.54.0",
+        "@rollup/rollup-win32-x64-gnu": "4.54.0",
+        "@rollup/rollup-win32-x64-msvc": "4.54.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/ts-api-utils": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.3.0.tgz",
+      "integrity": "sha512-6eg3Y9SF7SsAvGzRHQvvc1skDAhwI4YQ32ui1scxD1Ccr0G5qIIbUBT3pFTKX8kmWIQClHobtUdNuaBgwdfdWg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4"
+      }
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typescript-eslint": {
+      "version": "8.51.0",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.51.0.tgz",
+      "integrity": "sha512-jh8ZuM5oEh2PSdyQG9YAEM1TCGuWenLSuSUhf/irbVUNW9O5FhbFVONviN2TgMTBnUmyHv7E56rYnfLZK6TkiA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/eslint-plugin": "8.51.0",
+        "@typescript-eslint/parser": "8.51.0",
+        "@typescript-eslint/typescript-estree": "8.51.0",
+        "@typescript-eslint/utils": "8.51.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.0.tgz",
+      "integrity": "sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.2.1.tgz",
+      "integrity": "sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-validation-error": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz",
+      "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      }
+    }
+  }
+}
diff --git a/frontend/package.json b/frontend/package.json
new file mode 100644
index 0000000..eded7cd
--- /dev/null
+++ b/frontend/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.4"
+  }
+}
diff --git a/frontend/public/audio-processor.js b/frontend/public/audio-processor.js
new file mode 100644
index 0000000..d6fc838
--- /dev/null
+++ b/frontend/public/audio-processor.js
@@ -0,0 +1,72 @@
+/**
+ * AudioWorklet processor for capturing and resampling microphone audio
+ * Buffers to 100ms chunks (1600 samples at 16kHz) to meet AssemblyAI requirements
+ * Outputs Float32 audio (backend handles conversion to PCM16)
+ */
+class AudioProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    this.sourceSampleRate = options.processorOptions.sourceSampleRate;
+    this.targetSampleRate = 16000;
+    this.resampleRatio = this.sourceSampleRate / this.targetSampleRate;
+
+    // Input buffer for resampling
+    this.inputBuffer = null;
+
+    // Output buffer to collect 100ms of resampled audio (1600 samples at 16kHz)
+    // AssemblyAI requires chunks between 50-1000ms
+    this.outputBuffer = [];
+    this.outputBufferSize = 1600; // 100ms at 16kHz
+  }
+
+  process(inputs) {
+    const inputChannel = inputs[0][0];
+    if (!inputChannel) return true;
+
+    // Accumulate input samples
+    const currentLength = this.inputBuffer ? this.inputBuffer.length : 0;
+    const newBuffer = new Float32Array(currentLength + inputChannel.length);
+    if (this.inputBuffer) {
+      newBuffer.set(this.inputBuffer, 0);
+    }
+    newBuffer.set(inputChannel, currentLength);
+    this.inputBuffer = newBuffer;
+
+    // Resample to 16kHz
+    const numOutputSamples = Math.floor(this.inputBuffer.length / this.resampleRatio);
+    if (numOutputSamples === 0) return true;
+
+    const resampledData = new Float32Array(numOutputSamples);
+    for (let i = 0; i < numOutputSamples; i++) {
+      const correspondingInputIndex = i * this.resampleRatio;
+      const lowerIndex = Math.floor(correspondingInputIndex);
+      const upperIndex = Math.ceil(correspondingInputIndex);
+      const interpolationFactor = correspondingInputIndex - lowerIndex;
+
+      const lowerValue = this.inputBuffer[lowerIndex] || 0;
+      const upperValue = this.inputBuffer[upperIndex] || 0;
+
+      resampledData[i] = lowerValue + (upperValue - lowerValue) * interpolationFactor;
+    }
+
+    // Keep unconsumed input samples
+    const consumedInputSamples = numOutputSamples * this.resampleRatio;
+    this.inputBuffer = this.inputBuffer.slice(Math.round(consumedInputSamples));
+
+    // Add Float32 samples to output buffer
+    for (let i = 0; i < resampledData.length; i++) {
+      this.outputBuffer.push(resampledData[i]);
+
+      // When we have 100ms of audio (1600 samples), send it as Float32
+      if (this.outputBuffer.length >= this.outputBufferSize) {
+        const float32Array = new Float32Array(this.outputBuffer);
+        this.port.postMessage(float32Array.buffer, [float32Array.buffer]);
+        this.outputBuffer = [];
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('audio-processor', AudioProcessor);
diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg
new file mode 100644
index 0000000..e7b8dfb
--- /dev/null
+++ b/frontend/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
new file mode 100644
index 0000000..e6f1697
--- /dev/null
+++ b/frontend/src/App.tsx
@@ -0,0 +1,33 @@
+import { AppProvider } from './context/AppContext';
+import { Header } from './components/Header';
+import { ChatSection } from './components/ChatSection';
+import { FlashcardsSection } from './components/FlashcardsSection';
+import './styles/main.css';
+
+function AppContent() {
+  return (
+    <>
+      <Header />
+      <main className="main">
+        <div className="container">
+          <div className="app-grid">
+            <ChatSection />
+            <FlashcardsSection />
+          </div>
+        </div>
+      </main>
+      {/* Hidden audio element for iOS compatibility */}
+      <audio id="iosAudioElement" style={{ display: 'none' }} playsInline />
+    </>
+  );
+}
+
+function App() {
+  return (
+    <AppProvider>
+      <AppContent />
+    </AppProvider>
+  );
+}
+
+export default App;
diff --git a/frontend/src/components/ChatSection.tsx b/frontend/src/components/ChatSection.tsx
new file mode 100644
index 0000000..0143564
--- /dev/null
+++ b/frontend/src/components/ChatSection.tsx
@@ -0,0 +1,166 @@
+import { useEffect, useRef, useCallback } from 'react';
+import { useApp } from '../context/AppContext';
+import { Message } from './Message';
+import { StreamingMessage } from './StreamingMessage';
+
+export function ChatSection() {
+  const { state, toggleRecording, restartConversation } = useApp();
+  const {
+    chatHistory,
+    currentTranscript,
+    pendingTranscription,
+    streamingLLMResponse,
+    isRecording,
+    speechDetected,
+    connectionStatus,
+    currentResponseId,
+  } = state;
+
+  const messagesContainerRef = useRef<HTMLDivElement>(null);
+  const responseIdRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    responseIdRef.current = currentResponseId;
+  }, [currentResponseId]);
+
+  // Instant scroll to bottom - used during streaming/typing
+  const scrollToBottomInstant = useCallback(() => {
+    if (messagesContainerRef.current) {
+      messagesContainerRef.current.scrollTop =
+        messagesContainerRef.current.scrollHeight;
+    }
+  }, []);
+
+  // Smooth scroll to bottom - used for new messages
+  const scrollToBottomSmooth = useCallback(() => {
+    requestAnimationFrame(() => {
+      if (messagesContainerRef.current) {
+        messagesContainerRef.current.scrollTo({
+          top: messagesContainerRef.current.scrollHeight,
+          behavior: 'smooth',
+        });
+      }
+    });
+  }, []);
+
+  // Scroll when chat history changes (new messages added)
+  useEffect(() => {
+    scrollToBottomSmooth();
+  }, [chatHistory, scrollToBottomSmooth]);
+
+  // Scroll when streaming source content updates
+  useEffect(() => {
+    scrollToBottomInstant();
+  }, [currentTranscript, pendingTranscription, streamingLLMResponse, scrollToBottomInstant]);
+
+  // Callback for child components to trigger scroll during typewriter animation
+  const handleContentUpdate = useCallback(() => {
+    scrollToBottomInstant();
+  }, [scrollToBottomInstant]);
+
+  const handleLLMTypewriterComplete = useCallback(() => {
+    // Completion is handled in AppContext
+  }, []);
+
+  const isConnected = connectionStatus === 'connected';
+
+  return (
+    <section className="chat-section">
+      <div className="section-header">
+        <h2>Conversation</h2>
+        <div className="button-group">
+          <button
+            className="restart-button"
+            id="restartButton"
+            onClick={restartConversation}
+            disabled={!isConnected}
+            title="Restart conversation"
+          >
+            <svg
+              width="20"
+              height="20"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              strokeWidth="1"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            >
+              <path d="M21.5 2v6h-6M21.5 8A9.5 9.5 0 0 0 12 2.5 9.5 9.5 0 0 0 2.5 12 9.5 9.5 0 0 0 12 21.5 9.5 9.5 0 0 0 21.5 12" />
+            </svg>
+          </button>
+          <button
+            className={`mic-button ${isRecording ? 'recording' : ''}`}
+            id="micButton"
+            onClick={toggleRecording}
+            disabled={!isConnected}
+          >
+            <svg
+              width="24"
+              height="24"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+            >
+              <path d="M12 1a4 4 0 0 0-4 4v6a4 4 0 0 0 8 0V5a4 4 0 0 0-4-4z" />
+              <path d="M19 10v1a7 7 0 0 1-14 0v-1" />
+              <line x1="12" y1="19" x2="12" y2="23" />
+              <line x1="8" y1="23" x2="16" y2="23" />
+            </svg>
+          </button>
+        </div>
+      </div>
+      <div className="chat-container">
+        <div className="messages" id="messages" ref={messagesContainerRef}>
+          {/* Render existing conversation history */}
+          {chatHistory.map((message, index) => (
+            <Message key={`msg-${index}`} message={message} />
+          ))}
+
+          {/* Real-time transcript (while speaking) */}
+          {speechDetected && isRecording && !pendingTranscription && (
+            <div
+              className="message learner streaming realtime"
+              id="realtime-transcript"
+            >
+              <span className="transcript-text">{currentTranscript}</span>
+              {!currentTranscript && (
+                <span className="loading-dots">
+                  <span></span>
+                  <span></span>
+                  <span></span>
+                </span>
+              )}
+            </div>
+          )}
+
+          {/* Pending user transcription (final) - no typewriter, shown immediately */}
+          {pendingTranscription && (
+            <PendingTranscription text={pendingTranscription} />
+          )}
+
+          {/* Streaming LLM response */}
+          {streamingLLMResponse && (
+            <StreamingMessage
+              text={streamingLLMResponse}
+              onComplete={handleLLMTypewriterComplete}
+              onContentUpdate={handleContentUpdate}
+            />
+          )}
+        </div>
+        <div className="current-transcript" id="currentTranscript">
+          {currentTranscript}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+// Simple component to show finalized user transcription (no typewriter effect)
+function PendingTranscription({ text }: { text: string }) {
+  return (
+    <div className="message learner" id="pending-transcription">
+      {text}
+    </div>
+  );
+}
diff --git a/frontend/src/components/Flashcard.tsx b/frontend/src/components/Flashcard.tsx
new file mode 100644
index 0000000..459e45c
--- /dev/null
+++ b/frontend/src/components/Flashcard.tsx
@@ -0,0 +1,61 @@
+import { useState, useCallback } from 'react';
+import type { Flashcard as FlashcardType } from '../types';
+
+interface FlashcardProps {
+  flashcard: FlashcardType;
+  onCardClick?: (flashcard: FlashcardType) => void;
+}
+
+function escapeHtml(text: string): string {
+  const div = document.createElement('div');
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+export function Flashcard({ flashcard, onCardClick }: FlashcardProps) {
+  const [isFlipped, setIsFlipped] = useState(false);
+
+  const handleClick = useCallback(() => {
+    setIsFlipped((prev) => !prev);
+    onCardClick?.(flashcard);
+  }, [flashcard, onCardClick]);
+
+  // Support both new 'targetWord' and legacy 'spanish' field
+  const targetWord =
+    flashcard.targetWord || flashcard.spanish || flashcard.word || '';
+  const english = flashcard.english || flashcard.translation || '';
+  const example = flashcard.example || flashcard.example_sentence || '';
+  const mnemonic = flashcard.mnemonic || '';
+
+  return (
+    <div
+      className={`flashcard ${isFlipped ? 'flipped' : ''}`}
+      onClick={handleClick}
+    >
+      <div className="flashcard-inner">
+        <div className="flashcard-front">
+          <div
+            className="flashcard-target-word"
+            dangerouslySetInnerHTML={{ __html: escapeHtml(targetWord) }}
+          />
+        </div>
+        <div className="flashcard-back">
+          <div
+            className="flashcard-english"
+            dangerouslySetInnerHTML={{ __html: escapeHtml(english) }}
+          />
+          <div
+            className="flashcard-example"
+            dangerouslySetInnerHTML={{ __html: escapeHtml(example) }}
+          />
+          {mnemonic && (
+            <div className="flashcard-mnemonic">
+              <span className="mnemonic-label">Remember:</span>{' '}
+              <span dangerouslySetInnerHTML={{ __html: escapeHtml(mnemonic) }} />
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
new file mode 100644
index 0000000..3659165
--- /dev/null
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -0,0 +1,125 @@
+import { useState, useCallback } from 'react';
+import { useApp } from '../context/AppContext';
+import { Flashcard } from './Flashcard';
+import type { Flashcard as FlashcardType } from '../types';
+
+export function FlashcardsSection() {
+  const { state, wsClient } = useApp();
+  const { flashcards, currentLanguage } = state;
+  const [isExporting, setIsExporting] = useState(false);
+
+  const handleCardClick = useCallback(
+    (card: FlashcardType) => {
+      wsClient.send({ type: 'flashcard_clicked', card });
+    },
+    [wsClient]
+  );
+
+  const exportToAnki = useCallback(async () => {
+    const validFlashcards = flashcards.filter((flashcard) => {
+      const targetWord = flashcard.targetWord || flashcard.spanish;
+      return (
+        targetWord &&
+        flashcard.english &&
+        targetWord.trim() !== '' &&
+        flashcard.english.trim() !== ''
+      );
+    });
+
+    if (validFlashcards.length === 0) {
+      alert('No valid flashcards to export');
+      return;
+    }
+
+    setIsExporting(true);
+
+    try {
+      const languageNames: Record<string, string> = {
+        es: 'Spanish',
+        ja: 'Japanese',
+        fr: 'French',
+      };
+      const languageName = languageNames[currentLanguage] || 'Language';
+
+      const response = await fetch('/api/export-anki', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          flashcards: validFlashcards,
+          deckName: `Aprendemo ${languageName} Cards`,
+          languageCode: currentLanguage,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Export failed');
+      }
+
+      const blob = await response.blob();
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `aprendemo_${currentLanguage}_cards.apkg`;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+
+      console.log('ANKI deck exported successfully!');
+    } catch (error) {
+      console.error('Error exporting to ANKI:', error);
+      alert('Failed to export flashcards to ANKI');
+    } finally {
+      setIsExporting(false);
+    }
+  }, [flashcards, currentLanguage]);
+
+  // Sort flashcards by timestamp (most recent first)
+  const sortedFlashcards = [...flashcards].sort((a, b) => {
+    const timeA = new Date(a.timestamp || 0).getTime();
+    const timeB = new Date(b.timestamp || 0).getTime();
+    return timeB - timeA;
+  });
+
+  const cardCount = flashcards.length;
+  const canExport = cardCount >= 1;
+
+  return (
+    <section className="flashcards-section">
+      <div className="section-header">
+        <h2>Flashcards</h2>
+        <span
+          id="cardCount"
+          className={`card-count ${canExport ? 'exportable' : ''}`}
+          onClick={canExport && !isExporting ? exportToAnki : undefined}
+          style={{
+            cursor: canExport && !isExporting ? 'pointer' : 'default',
+          }}
+        >
+          {isExporting
+            ? 'Exporting...'
+            : canExport
+              ? `Export ${cardCount} card${cardCount !== 1 ? 's' : ''} to Anki`
+              : `${cardCount} card${cardCount !== 1 ? 's' : ''}`}
+        </span>
+      </div>
+      <div className="flashcards-container">
+        <div className="flashcards-grid" id="flashcardsGrid">
+        {sortedFlashcards.length === 0 ? (
+          <div className="empty-state"></div>
+        ) : (
+          sortedFlashcards.map((flashcard, index) => (
+            <Flashcard
+              key={`card-${flashcard.targetWord || flashcard.spanish || index}`}
+              flashcard={flashcard}
+              onCardClick={handleCardClick}
+            />
+          ))
+        )}
+        </div>
+      </div>
+    </section>
+  );
+}
diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
new file mode 100644
index 0000000..d36e663
--- /dev/null
+++ b/frontend/src/components/Header.tsx
@@ -0,0 +1,50 @@
+import { useApp } from '../context/AppContext';
+
+export function Header() {
+  const { state, changeLanguage } = useApp();
+  const { connectionStatus, currentLanguage, availableLanguages } = state;
+
+  const statusMessages: Record<string, string> = {
+    connecting: 'Connecting...',
+    connected: 'Connected',
+    disconnected: 'Disconnected',
+  };
+
+  const handleLanguageChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
+    const newLanguage = e.target.value;
+    if (newLanguage !== currentLanguage) {
+      changeLanguage(newLanguage);
+    }
+  };
+
+  return (
+    <header className="header">
+      <div className="container">
+        <h1 className="logo">Aprendemo</h1>
+        <div className="header-controls">
+          <div className="language-selector">
+            <select
+              id="languageSelect"
+              className="language-dropdown"
+              value={currentLanguage}
+              onChange={handleLanguageChange}
+              disabled={connectionStatus !== 'connected'}
+            >
+              {availableLanguages.map((lang) => (
+                <option key={lang.code} value={lang.code}>
+                  {lang.flag} {lang.name}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div className="status-indicator">
+            <span className={`status-dot ${connectionStatus}`} id="statusDot" />
+            <span className="status-text" id="statusText">
+              {statusMessages[connectionStatus] || 'Unknown'}
+            </span>
+          </div>
+        </div>
+      </div>
+    </header>
+  );
+}
diff --git a/frontend/src/components/Message.tsx b/frontend/src/components/Message.tsx
new file mode 100644
index 0000000..4b05efe
--- /dev/null
+++ b/frontend/src/components/Message.tsx
@@ -0,0 +1,86 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import type { ChatMessage } from '../types';
+import { TranslationTooltip } from './TranslationTooltip';
+
+interface MessageProps {
+  message: ChatMessage;
+}
+
+export function Message({ message }: MessageProps) {
+  const [showTooltip, setShowTooltip] = useState(false);
+  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });
+  const messageRef = useRef<HTMLDivElement>(null);
+  const hoverTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const hideTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const handleMouseEnter = useCallback(() => {
+    if (message.role !== 'teacher') return;
+
+    if (hideTimeoutRef.current) {
+      clearTimeout(hideTimeoutRef.current);
+      hideTimeoutRef.current = null;
+    }
+
+    hoverTimeoutRef.current = setTimeout(() => {
+      if (messageRef.current) {
+        const rect = messageRef.current.getBoundingClientRect();
+        setTooltipPosition({
+          x: rect.left + window.scrollX,
+          y: rect.top + window.scrollY - 8,
+        });
+        setShowTooltip(true);
+      }
+    }, 300);
+  }, [message.role]);
+
+  const handleMouseLeave = useCallback(() => {
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+      hoverTimeoutRef.current = null;
+    }
+
+    hideTimeoutRef.current = setTimeout(() => {
+      setShowTooltip(false);
+    }, 150);
+  }, []);
+
+  const handleTooltipMouseEnter = useCallback(() => {
+    if (hideTimeoutRef.current) {
+      clearTimeout(hideTimeoutRef.current);
+      hideTimeoutRef.current = null;
+    }
+  }, []);
+
+  const handleTooltipMouseLeave = useCallback(() => {
+    setShowTooltip(false);
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (hoverTimeoutRef.current) clearTimeout(hoverTimeoutRef.current);
+      if (hideTimeoutRef.current) clearTimeout(hideTimeoutRef.current);
+    };
+  }, []);
+
+  return (
+    <>
+      <div
+        ref={messageRef}
+        className={`message ${message.role}`}
+        onMouseEnter={handleMouseEnter}
+        onMouseLeave={handleMouseLeave}
+      >
+        {message.content}
+      </div>
+      {message.role === 'teacher' && (
+        <TranslationTooltip
+          text={message.content}
+          visible={showTooltip}
+          position={tooltipPosition}
+          onMouseEnter={handleTooltipMouseEnter}
+          onMouseLeave={handleTooltipMouseLeave}
+        />
+      )}
+    </>
+  );
+}
diff --git a/frontend/src/components/StreamingMessage.tsx b/frontend/src/components/StreamingMessage.tsx
new file mode 100644
index 0000000..7712d9a
--- /dev/null
+++ b/frontend/src/components/StreamingMessage.tsx
@@ -0,0 +1,94 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { useTypewriter } from '../hooks/useTypewriter';
+import { TranslationTooltip } from './TranslationTooltip';
+
+interface StreamingMessageProps {
+  text: string;
+  onComplete?: () => void;
+  onContentUpdate?: () => void;
+}
+
+export function StreamingMessage({ text, onComplete, onContentUpdate }: StreamingMessageProps) {
+  const { displayedText, isTyping } = useTypewriter(text, {
+    speed: 25,
+    onComplete,
+    onContentUpdate,
+  });
+
+  const [showTooltip, setShowTooltip] = useState(false);
+  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });
+  const messageRef = useRef<HTMLDivElement>(null);
+  const hoverTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const hideTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const handleMouseEnter = useCallback(() => {
+    if (hideTimeoutRef.current) {
+      clearTimeout(hideTimeoutRef.current);
+      hideTimeoutRef.current = null;
+    }
+
+    hoverTimeoutRef.current = setTimeout(() => {
+      if (messageRef.current) {
+        const rect = messageRef.current.getBoundingClientRect();
+        setTooltipPosition({
+          x: rect.left + window.scrollX,
+          y: rect.top + window.scrollY - 8,
+        });
+        setShowTooltip(true);
+      }
+    }, 300);
+  }, []);
+
+  const handleMouseLeave = useCallback(() => {
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+      hoverTimeoutRef.current = null;
+    }
+
+    hideTimeoutRef.current = setTimeout(() => {
+      setShowTooltip(false);
+    }, 150);
+  }, []);
+
+  const handleTooltipMouseEnter = useCallback(() => {
+    if (hideTimeoutRef.current) {
+      clearTimeout(hideTimeoutRef.current);
+      hideTimeoutRef.current = null;
+    }
+  }, []);
+
+  const handleTooltipMouseLeave = useCallback(() => {
+    setShowTooltip(false);
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (hoverTimeoutRef.current) clearTimeout(hoverTimeoutRef.current);
+      if (hideTimeoutRef.current) clearTimeout(hideTimeoutRef.current);
+    };
+  }, []);
+
+  // Get text for translation (remove cursor)
+  const textForTranslation = displayedText.replace('▊', '').trim();
+
+  return (
+    <>
+      <div
+        ref={messageRef}
+        className="message teacher streaming"
+        onMouseEnter={handleMouseEnter}
+        onMouseLeave={handleMouseLeave}
+      >
+        {displayedText}
+        {isTyping && <span className="streaming-cursor">▊</span>}
+      </div>
+      <TranslationTooltip
+        text={textForTranslation}
+        visible={showTooltip}
+        position={tooltipPosition}
+        onMouseEnter={handleTooltipMouseEnter}
+        onMouseLeave={handleTooltipMouseLeave}
+      />
+    </>
+  );
+}
diff --git a/frontend/src/components/TranslationTooltip.tsx b/frontend/src/components/TranslationTooltip.tsx
new file mode 100644
index 0000000..f4c65d1
--- /dev/null
+++ b/frontend/src/components/TranslationTooltip.tsx
@@ -0,0 +1,70 @@
+import { useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import { useTranslator } from '../hooks/useTranslator';
+
+interface TranslationTooltipProps {
+  text: string;
+  visible: boolean;
+  position: { x: number; y: number };
+  onMouseEnter?: () => void;
+  onMouseLeave?: () => void;
+}
+
+export function TranslationTooltip({
+  text,
+  visible,
+  position,
+  onMouseEnter,
+  onMouseLeave,
+}: TranslationTooltipProps) {
+  const { translation, isLoading, translate, clearTranslation } = useTranslator();
+  const tooltipRef = useRef<HTMLDivElement>(null);
+  const lastTextRef = useRef<string>('');
+
+  useEffect(() => {
+    if (visible && text && text !== lastTextRef.current) {
+      lastTextRef.current = text;
+      translate(text);
+    } else if (!visible) {
+      lastTextRef.current = '';
+      clearTranslation();
+    }
+  }, [visible, text, translate, clearTranslation]);
+
+  // Adjust position after content loads
+  useEffect(() => {
+    if (visible && tooltipRef.current && !isLoading) {
+      const tooltipRect = tooltipRef.current.getBoundingClientRect();
+      tooltipRef.current.style.top = `${position.y - tooltipRect.height}px`;
+    }
+  }, [visible, isLoading, position.y, translation]);
+
+  if (!visible) return null;
+
+  const tooltipContent = (
+    <div
+      ref={tooltipRef}
+      className={`translation-tooltip ${visible ? 'visible' : ''} ${isLoading ? 'loading' : ''}`}
+      style={{
+        left: `${position.x}px`,
+        top: `${position.y}px`,
+        maxWidth: '400px',
+      }}
+      onMouseEnter={onMouseEnter}
+      onMouseLeave={onMouseLeave}
+    >
+      <div className="translation-content">
+        <span className="translation-text">
+          {isLoading ? '' : translation || 'Translation unavailable'}
+        </span>
+      </div>
+      <div className="translation-loading">
+        <span></span>
+        <span></span>
+        <span></span>
+      </div>
+    </div>
+  );
+
+  return createPortal(tooltipContent, document.body);
+}
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
new file mode 100644
index 0000000..1677139
--- /dev/null
+++ b/frontend/src/context/AppContext.tsx
@@ -0,0 +1,619 @@
+import React, {
+  createContext,
+  useContext,
+  useReducer,
+  useEffect,
+  useRef,
+  useCallback,
+  type ReactNode,
+} from 'react';
+import type {
+  AppState,
+  ChatMessage,
+  Flashcard,
+  Language,
+  ConnectionStatus,
+  AudioStreamData,
+} from '../types';
+import { Storage } from '../services/Storage';
+import { WebSocketClient } from '../services/WebSocketClient';
+import { AudioHandler } from '../services/AudioHandler';
+import { AudioPlayer } from '../services/AudioPlayer';
+
+// Action types
+type AppAction =
+  | { type: 'SET_CONNECTION_STATUS'; payload: ConnectionStatus }
+  | { type: 'SET_LANGUAGE'; payload: string }
+  | { type: 'SET_AVAILABLE_LANGUAGES'; payload: Language[] }
+  | { type: 'SET_CHAT_HISTORY'; payload: ChatMessage[] }
+  | { type: 'ADD_MESSAGE'; payload: ChatMessage }
+  | { type: 'SET_CURRENT_TRANSCRIPT'; payload: string }
+  | { type: 'SET_PENDING_TRANSCRIPTION'; payload: string | null }
+  | { type: 'SET_STREAMING_LLM_RESPONSE'; payload: string }
+  | { type: 'APPEND_LLM_CHUNK'; payload: string }
+  | { type: 'SET_LLM_COMPLETE'; payload: boolean }
+  | { type: 'SET_RESPONSE_ID'; payload: string | null }
+  | { type: 'SET_RECORDING'; payload: boolean }
+  | { type: 'SET_SPEECH_DETECTED'; payload: boolean }
+  | { type: 'SET_FLASHCARDS'; payload: Flashcard[] }
+  | { type: 'ADD_FLASHCARDS'; payload: Flashcard[] }
+  | { type: 'RESET_STREAMING_STATE' }
+  | { type: 'RESET_CONVERSATION' };
+
+// Initial state
+const createInitialState = (storage: Storage): AppState => ({
+  connectionStatus: 'connecting',
+  currentLanguage: storage.getLanguage(),
+  availableLanguages: [],
+  chatHistory: [],
+  currentTranscript: '',
+  pendingTranscription: null,
+  streamingLLMResponse: '',
+  llmResponseComplete: false,
+  currentResponseId: null,
+  isRecording: false,
+  speechDetected: false,
+  flashcards: [],
+  userId: storage.getOrCreateUserId(),
+});
+
+// Reducer
+function appReducer(state: AppState, action: AppAction): AppState {
+  switch (action.type) {
+    case 'SET_CONNECTION_STATUS':
+      return { ...state, connectionStatus: action.payload };
+    case 'SET_LANGUAGE':
+      return { ...state, currentLanguage: action.payload };
+    case 'SET_AVAILABLE_LANGUAGES':
+      return { ...state, availableLanguages: action.payload };
+    case 'SET_CHAT_HISTORY':
+      return { ...state, chatHistory: action.payload };
+    case 'ADD_MESSAGE':
+      return { ...state, chatHistory: [...state.chatHistory, action.payload] };
+    case 'SET_CURRENT_TRANSCRIPT':
+      return { ...state, currentTranscript: action.payload };
+    case 'SET_PENDING_TRANSCRIPTION':
+      return { ...state, pendingTranscription: action.payload };
+    case 'SET_STREAMING_LLM_RESPONSE':
+      return { ...state, streamingLLMResponse: action.payload };
+    case 'APPEND_LLM_CHUNK':
+      return {
+        ...state,
+        streamingLLMResponse: state.streamingLLMResponse + action.payload,
+      };
+    case 'SET_LLM_COMPLETE':
+      return { ...state, llmResponseComplete: action.payload };
+    case 'SET_RESPONSE_ID':
+      return { ...state, currentResponseId: action.payload };
+    case 'SET_RECORDING':
+      return { ...state, isRecording: action.payload };
+    case 'SET_SPEECH_DETECTED':
+      return { ...state, speechDetected: action.payload };
+    case 'SET_FLASHCARDS':
+      return { ...state, flashcards: action.payload };
+    case 'ADD_FLASHCARDS': {
+      const existingWords = new Set(
+        state.flashcards.map((f) =>
+          (f.targetWord || f.spanish || '').toLowerCase()
+        )
+      );
+      const newCards = action.payload.filter(
+        (f) =>
+          !existingWords.has((f.targetWord || f.spanish || '').toLowerCase())
+      );
+      return { ...state, flashcards: [...state.flashcards, ...newCards] };
+    }
+    case 'RESET_STREAMING_STATE':
+      return {
+        ...state,
+        streamingLLMResponse: '',
+        llmResponseComplete: false,
+        currentResponseId: null,
+      };
+    case 'RESET_CONVERSATION':
+      return {
+        ...state,
+        chatHistory: [],
+        currentTranscript: '',
+        pendingTranscription: null,
+        streamingLLMResponse: '',
+        llmResponseComplete: false,
+        currentResponseId: null,
+        speechDetected: false,
+      };
+    default:
+      return state;
+  }
+}
+
+// Context type
+interface AppContextType {
+  state: AppState;
+  dispatch: React.Dispatch<AppAction>;
+  storage: Storage;
+  wsClient: WebSocketClient;
+  audioHandler: AudioHandler;
+  audioPlayer: AudioPlayer;
+  // Actions
+  toggleRecording: () => Promise<void>;
+  restartConversation: () => void;
+  changeLanguage: (newLanguage: string) => void;
+  handleInterrupt: () => void;
+}
+
+const AppContext = createContext<AppContextType | null>(null);
+
+// Provider
+interface AppProviderProps {
+  children: ReactNode;
+}
+
+export function AppProvider({ children }: AppProviderProps) {
+  const storageRef = useRef(new Storage());
+  const wsClientRef = useRef(
+    new WebSocketClient(
+      `ws://${window.location.hostname}:3000`
+    )
+  );
+  const audioHandlerRef = useRef(new AudioHandler());
+  const audioPlayerRef = useRef(new AudioPlayer());
+
+  const [state, dispatch] = useReducer(
+    appReducer,
+    storageRef.current,
+    createInitialState
+  );
+
+  // Refs for tracking state in callbacks
+  const stateRef = useRef(state);
+  stateRef.current = state;
+
+  const pendingLLMResponseRef = useRef<string | null>(null);
+  const lastPendingTranscriptionRef = useRef<string | null>(null);
+
+  // Refs for callbacks to avoid effect dependency issues
+  const handleInterruptRef = useRef<() => void>(() => {});
+  const checkAndUpdateConversationRef = useRef<() => void>(() => {});
+
+  // Initialize audio player
+  useEffect(() => {
+    audioPlayerRef.current.initialize().catch(console.error);
+    return () => {
+      audioPlayerRef.current.destroy();
+    };
+  }, []);
+
+  // Load initial state
+  useEffect(() => {
+    const storage = storageRef.current;
+    const flashcards = storage.getFlashcards(state.currentLanguage);
+    dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+  }, [state.currentLanguage]);
+
+  // Fetch available languages
+  useEffect(() => {
+    const fetchLanguages = async () => {
+      try {
+        const response = await fetch('/api/languages');
+        if (response.ok) {
+          const data = await response.json();
+          dispatch({ type: 'SET_AVAILABLE_LANGUAGES', payload: data.languages });
+
+          const isValidLanguage = data.languages.some(
+            (lang: Language) => lang.code === state.currentLanguage
+          );
+          if (!isValidLanguage) {
+            dispatch({
+              type: 'SET_LANGUAGE',
+              payload: data.defaultLanguage || 'es',
+            });
+          }
+        }
+      } catch (error) {
+        console.error('Failed to fetch languages:', error);
+        dispatch({
+          type: 'SET_AVAILABLE_LANGUAGES',
+          payload: [
+            { code: 'es', name: 'Spanish', nativeName: 'Español', flag: '🇲🇽' },
+            { code: 'ja', name: 'Japanese', nativeName: '日本語', flag: '🇯🇵' },
+            { code: 'fr', name: 'French', nativeName: 'Français', flag: '🇫🇷' },
+          ],
+        });
+      }
+    };
+    fetchLanguages();
+  }, []);
+
+  // Check and update conversation
+  const checkAndUpdateConversation = useCallback(() => {
+    const currentState = stateRef.current;
+    const pendingTranscription = currentState.pendingTranscription;
+    const pendingLLMResponse = pendingLLMResponseRef.current;
+
+    if (pendingTranscription && pendingLLMResponse) {
+      const lastUserMessage = currentState.chatHistory
+        .filter((m) => m.role === 'learner')
+        .pop();
+      const lastTeacherMessage = currentState.chatHistory
+        .filter((m) => m.role === 'teacher')
+        .pop();
+
+      const isDuplicate =
+        lastUserMessage?.content === pendingTranscription &&
+        lastTeacherMessage?.content === pendingLLMResponse;
+
+      if (isDuplicate) {
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+        pendingLLMResponseRef.current = null;
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        return;
+      }
+
+      const teacherAlreadyAdded = lastTeacherMessage?.content === pendingLLMResponse;
+      const userAlreadyAdded = lastUserMessage?.content === pendingTranscription;
+
+      const storage = storageRef.current;
+      const wsClient = wsClientRef.current;
+
+      if (teacherAlreadyAdded && !userAlreadyAdded) {
+        storage.addMessage('user', pendingTranscription);
+        dispatch({
+          type: 'ADD_MESSAGE',
+          payload: { role: 'learner', content: pendingTranscription },
+        });
+
+        const conversationHistory = storage.getConversationHistory();
+        wsClient.send({ type: 'conversation_update', data: conversationHistory });
+
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+        pendingLLMResponseRef.current = null;
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        return;
+      }
+
+      storage.addMessage('user', pendingTranscription);
+      storage.addMessage('assistant', pendingLLMResponse);
+
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'learner', content: pendingTranscription },
+      });
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'teacher', content: pendingLLMResponse },
+      });
+
+      const conversationHistory = storage.getConversationHistory();
+      wsClient.send({ type: 'conversation_update', data: conversationHistory });
+
+      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+      pendingLLMResponseRef.current = null;
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+    }
+  }, []);
+
+  // Keep refs updated
+  checkAndUpdateConversationRef.current = checkAndUpdateConversation;
+
+  // Handle interrupt
+  const handleInterrupt = useCallback(() => {
+    console.log('[AppContext] Handling interrupt');
+    const audioPlayer = audioPlayerRef.current;
+    audioPlayer.stop();
+
+    const currentState = stateRef.current;
+    if (currentState.streamingLLMResponse?.trim()) {
+      const frozenText = currentState.streamingLLMResponse;
+      pendingLLMResponseRef.current = frozenText;
+
+      if (currentState.pendingTranscription) {
+        checkAndUpdateConversationRef.current();
+      } else {
+        const lastTeacherMessage = currentState.chatHistory
+          .filter((m) => m.role === 'teacher')
+          .pop();
+
+        if (lastTeacherMessage?.content !== frozenText) {
+          dispatch({
+            type: 'ADD_MESSAGE',
+            payload: { role: 'teacher', content: frozenText },
+          });
+        }
+      }
+
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+    }
+  }, []);
+
+  // Keep refs updated
+  handleInterruptRef.current = handleInterrupt;
+
+  // Setup WebSocket event listeners - runs once on mount
+  useEffect(() => {
+    const wsClient = wsClientRef.current;
+    const storage = storageRef.current;
+    const audioPlayer = audioPlayerRef.current;
+
+    // Clear any existing listeners to prevent duplicates
+    wsClient.clearAllListeners();
+
+    wsClient.on('connection', (status) => {
+      dispatch({ type: 'SET_CONNECTION_STATUS', payload: status as ConnectionStatus });
+
+      if (status === 'connected') {
+        wsClient.send({
+          type: 'set_language',
+          languageCode: stateRef.current.currentLanguage,
+        });
+
+        const existingConversation = storage.getConversationHistory();
+        if (existingConversation.messages.length > 0) {
+          wsClient.send({
+            type: 'conversation_update',
+            data: existingConversation,
+          });
+        }
+      }
+    });
+
+    wsClient.on('transcript_update', (text) => {
+      dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: text as string });
+      dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
+    });
+
+    wsClient.on('speech_detected', (data) => {
+      dispatch({
+        type: 'SET_CURRENT_TRANSCRIPT',
+        payload: (data as { text?: string })?.text || '',
+      });
+      dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
+      handleInterruptRef.current();
+    });
+
+    wsClient.on('partial_transcript', (data) => {
+      const text = (data as { text?: string })?.text;
+      if (text) {
+        dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: text });
+        dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
+      }
+    });
+
+    wsClient.on('speech_ended', () => {
+      if (!stateRef.current.pendingTranscription) {
+        dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
+        dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+      }
+    });
+
+    wsClient.on('transcription', (data) => {
+      const text = (data as { text: string }).text;
+      audioPlayer.stop();
+
+      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
+      dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
+      dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+
+      if (
+        pendingLLMResponseRef.current &&
+        !stateRef.current.streamingLLMResponse
+      ) {
+        checkAndUpdateConversationRef.current();
+      }
+
+      if (
+        stateRef.current.streamingLLMResponse?.trim() &&
+        stateRef.current.llmResponseComplete &&
+        !pendingLLMResponseRef.current
+      ) {
+        pendingLLMResponseRef.current = stateRef.current.streamingLLMResponse;
+        checkAndUpdateConversationRef.current();
+      }
+
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+
+      if (lastPendingTranscriptionRef.current !== text) {
+        lastPendingTranscriptionRef.current = text;
+      }
+
+      checkAndUpdateConversationRef.current();
+    });
+
+    wsClient.on('llm_response_chunk', (data) => {
+      if (!stateRef.current.llmResponseComplete) {
+        dispatch({ type: 'APPEND_LLM_CHUNK', payload: (data as { text: string }).text });
+      }
+    });
+
+    wsClient.on('llm_response_complete', (data) => {
+      const responseId = `response_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+      dispatch({ type: 'SET_RESPONSE_ID', payload: responseId });
+      dispatch({ type: 'SET_LLM_COMPLETE', payload: true });
+
+      const finalText =
+        (data as { text?: string }).text || stateRef.current.streamingLLMResponse;
+      dispatch({ type: 'SET_STREAMING_LLM_RESPONSE', payload: finalText });
+    });
+
+    wsClient.on('audio_stream', (data) => {
+      const audioData = data as AudioStreamData;
+      audioPlayer.addAudioStream(
+        audioData.audio,
+        audioData.sampleRate,
+        false,
+        audioData.audioFormat
+      );
+    });
+
+    wsClient.on('audio_stream_complete', () => {
+      audioPlayer.markStreamComplete();
+    });
+
+    wsClient.on('interrupt', () => {
+      handleInterruptRef.current();
+    });
+
+    wsClient.on('flashcards_generated', (flashcards) => {
+      const cards = flashcards as Flashcard[];
+      const updatedFlashcards = storage.addFlashcards(
+        cards,
+        stateRef.current.currentLanguage
+      );
+      dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+    });
+
+    wsClient.on('language_changed', (data) => {
+      console.log(`Language changed to ${(data as { languageName: string }).languageName}`);
+    });
+
+    // Connect
+    wsClient.connect().catch((error) => {
+      console.error('WebSocket connection failed:', error);
+      dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'disconnected' });
+    });
+
+    // Cleanup - only runs on unmount
+    return () => {
+      wsClient.clearAllListeners();
+      wsClient.disconnect();
+    };
+  }, []); // Empty dependency array - only run on mount/unmount
+
+  // Audio chunk handler
+  useEffect(() => {
+    const audioHandler = audioHandlerRef.current;
+    const wsClient = wsClientRef.current;
+
+    const handleAudioChunk = (audioData: string) => {
+      wsClient.sendAudioChunk(audioData);
+    };
+
+    audioHandler.on('audioChunk', handleAudioChunk);
+
+    return () => {
+      audioHandler.off('audioChunk', handleAudioChunk);
+    };
+  }, []);
+
+  // User context on connect
+  useEffect(() => {
+    const wsClient = wsClientRef.current;
+
+    if (state.connectionStatus === 'connected') {
+      try {
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+        wsClient.send({
+          type: 'user_context',
+          timezone: tz,
+          userId: state.userId,
+          languageCode: state.currentLanguage,
+        });
+      } catch {
+        // ignore
+      }
+    }
+  }, [state.connectionStatus, state.userId, state.currentLanguage]);
+
+  // Toggle recording
+  const toggleRecording = useCallback(async () => {
+    const audioHandler = audioHandlerRef.current;
+
+    if (!state.isRecording) {
+      try {
+        await audioHandler.startStreaming();
+        dispatch({ type: 'SET_RECORDING', payload: true });
+        dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
+        dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+      } catch (error) {
+        console.error('Failed to start streaming:', error);
+        alert('Microphone access denied. Please enable microphone permissions.');
+      }
+    } else {
+      audioHandler.stopStreaming();
+      dispatch({ type: 'SET_RECORDING', payload: false });
+      dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
+      dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+    }
+  }, [state.isRecording]);
+
+  // Restart conversation
+  const restartConversation = useCallback(() => {
+    const audioHandler = audioHandlerRef.current;
+    const audioPlayer = audioPlayerRef.current;
+    const storage = storageRef.current;
+    const wsClient = wsClientRef.current;
+
+    if (state.isRecording) {
+      audioHandler.stopStreaming();
+      dispatch({ type: 'SET_RECORDING', payload: false });
+    }
+
+    audioPlayer.stop();
+    storage.clearConversation();
+
+    dispatch({ type: 'RESET_CONVERSATION' });
+    pendingLLMResponseRef.current = null;
+    lastPendingTranscriptionRef.current = null;
+
+    storage.saveState({ chatHistory: [] });
+
+    if (state.connectionStatus === 'connected') {
+      wsClient.send({ type: 'restart_conversation' });
+    }
+  }, [state.isRecording, state.connectionStatus]);
+
+  // Change language
+  const changeLanguage = useCallback(
+    (newLanguage: string) => {
+      const audioHandler = audioHandlerRef.current;
+      const audioPlayer = audioPlayerRef.current;
+      const storage = storageRef.current;
+      const wsClient = wsClientRef.current;
+
+      if (state.isRecording) {
+        audioHandler.stopStreaming();
+        dispatch({ type: 'SET_RECORDING', payload: false });
+      }
+
+      audioPlayer.stop();
+
+      dispatch({ type: 'SET_LANGUAGE', payload: newLanguage });
+      storage.saveLanguage(newLanguage);
+
+      storage.clearConversation();
+      dispatch({ type: 'RESET_CONVERSATION' });
+      pendingLLMResponseRef.current = null;
+      lastPendingTranscriptionRef.current = null;
+
+      const flashcards = storage.getFlashcards(newLanguage);
+      dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+
+      if (state.connectionStatus === 'connected') {
+        wsClient.send({ type: 'set_language', languageCode: newLanguage });
+      }
+    },
+    [state.isRecording, state.connectionStatus]
+  );
+
+  const value: AppContextType = {
+    state,
+    dispatch,
+    storage: storageRef.current,
+    wsClient: wsClientRef.current,
+    audioHandler: audioHandlerRef.current,
+    audioPlayer: audioPlayerRef.current,
+    toggleRecording,
+    restartConversation,
+    changeLanguage,
+    handleInterrupt,
+  };
+
+  return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
+}
+
+export function useApp() {
+  const context = useContext(AppContext);
+  if (!context) {
+    throw new Error('useApp must be used within an AppProvider');
+  }
+  return context;
+}
diff --git a/frontend/src/hooks/useTranslator.ts b/frontend/src/hooks/useTranslator.ts
new file mode 100644
index 0000000..5429d80
--- /dev/null
+++ b/frontend/src/hooks/useTranslator.ts
@@ -0,0 +1,26 @@
+import { useState, useCallback, useRef } from 'react';
+import { Translator } from '../services/Translator';
+
+export function useTranslator() {
+  const translatorRef = useRef(new Translator());
+  const [translation, setTranslation] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const translate = useCallback(async (text: string) => {
+    setIsLoading(true);
+    try {
+      const result = await translatorRef.current.translate(text, 'en', 'auto');
+      setTranslation(result);
+    } catch {
+      setTranslation(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const clearTranslation = useCallback(() => {
+    setTranslation(null);
+  }, []);
+
+  return { translation, isLoading, translate, clearTranslation };
+}
diff --git a/frontend/src/hooks/useTypewriter.ts b/frontend/src/hooks/useTypewriter.ts
new file mode 100644
index 0000000..77459dd
--- /dev/null
+++ b/frontend/src/hooks/useTypewriter.ts
@@ -0,0 +1,63 @@
+import { useState, useEffect, useRef } from 'react';
+
+interface UseTypewriterOptions {
+  speed?: number;
+  onComplete?: () => void;
+  onContentUpdate?: () => void;
+}
+
+export function useTypewriter(
+  text: string,
+  options: UseTypewriterOptions = {}
+) {
+  const { speed = 25, onComplete, onContentUpdate } = options;
+  const [displayedText, setDisplayedText] = useState('');
+  const [isTyping, setIsTyping] = useState(false);
+  const onCompleteRef = useRef(onComplete);
+  const onContentUpdateRef = useRef(onContentUpdate);
+  const hasCompletedRef = useRef(false);
+
+  // Keep callback refs up to date
+  useEffect(() => {
+    onCompleteRef.current = onComplete;
+  }, [onComplete]);
+
+  useEffect(() => {
+    onContentUpdateRef.current = onContentUpdate;
+  }, [onContentUpdate]);
+
+  useEffect(() => {
+    if (!text) {
+      setDisplayedText('');
+      setIsTyping(false);
+      hasCompletedRef.current = false;
+      return;
+    }
+
+    setIsTyping(true);
+    hasCompletedRef.current = false;
+    let index = 0;
+
+    const timer = setInterval(() => {
+      if (index < text.length) {
+        setDisplayedText(text.substring(0, index + 1));
+        index++;
+        // Notify parent of content update for scrolling
+        onContentUpdateRef.current?.();
+      } else {
+        clearInterval(timer);
+        setIsTyping(false);
+        if (!hasCompletedRef.current) {
+          hasCompletedRef.current = true;
+          onCompleteRef.current?.();
+        }
+      }
+    }, speed);
+
+    return () => {
+      clearInterval(timer);
+    };
+  }, [text, speed]);
+
+  return { displayedText, isTyping };
+}
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
new file mode 100644
index 0000000..4aff025
--- /dev/null
+++ b/frontend/src/main.tsx
@@ -0,0 +1,9 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/frontend/js/audio-handler.js b/frontend/src/services/AudioHandler.ts
similarity index 74%
rename from frontend/js/audio-handler.js
rename to frontend/src/services/AudioHandler.ts
index 8c51b90..b268fea 100644
--- a/frontend/js/audio-handler.js
+++ b/frontend/src/services/AudioHandler.ts
@@ -1,14 +1,19 @@
+import type { IOSAudioHandler } from '../types';
+
+type EventCallback = (data: string) => void;
+
 export class AudioHandler {
-  constructor() {
-    this.audioContext = null;
-    this.workletNode = null;
-    this.scriptProcessor = null;
-    this.stream = null;
-    this.microphone = null;
-    this.isStreaming = false;
-    this.listeners = new Map();
+  private audioContext: AudioContext | null = null;
+  private workletNode: AudioWorkletNode | null = null;
+  private scriptProcessor: ScriptProcessorNode | null = null;
+  private stream: MediaStream | null = null;
+  private microphone: MediaStreamAudioSourceNode | null = null;
+  private isStreaming = false;
+  private listeners = new Map<string, EventCallback[]>();
+  private isIOS: boolean;
+  private iosHandler: IOSAudioHandler | null;
 
-    // Check for iOS and use iOS handler if available
+  constructor() {
     this.isIOS =
       /iPad|iPhone|iPod/.test(navigator.userAgent) ||
       (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
@@ -20,41 +25,52 @@ export class AudioHandler {
     }
   }
 
-  setupIOSEventListeners() {
-    // Listen for iOS audio unlock event
-    window.addEventListener('ios-audio-unlocked', (event) => {
+  private setupIOSEventListeners(): void {
+    window.addEventListener('ios-audio-unlocked', ((event: CustomEvent) => {
       console.log('[AudioHandler] iOS audio unlocked');
       this.audioContext = event.detail.audioContext;
-    });
+    }) as EventListener);
 
-    // Listen for iOS audio errors
-    window.addEventListener('ios-audio-error', (event) => {
+    window.addEventListener('ios-audio-error', ((event: CustomEvent) => {
       console.error('[AudioHandler] iOS audio error:', event.detail.message);
       this.emit('error', event.detail);
-    });
+    }) as EventListener);
 
-    // Listen for iOS audio ended
     window.addEventListener('ios-audio-ended', () => {
       console.log('[AudioHandler] iOS audio playback ended');
-      this.emit('playback_finished');
+      this.emit('playback_finished', '');
     });
   }
 
-  on(event, callback) {
+  on(event: string, callback: EventCallback): void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, []);
     }
-    this.listeners.get(event).push(callback);
+    this.listeners.get(event)!.push(callback);
   }
 
-  emit(event, data) {
+  off(event: string, callback: EventCallback): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  clearAllListeners(): void {
+    this.listeners.clear();
+  }
+
+  private emit(event: string, data: string): void {
     const callbacks = this.listeners.get(event);
     if (callbacks) {
       callbacks.forEach((callback) => callback(data));
     }
   }
 
-  async startStreaming() {
+  async startStreaming(): Promise<void> {
     try {
       console.log('Starting continuous audio streaming...');
 
@@ -62,11 +78,9 @@ export class AudioHandler {
       if (this.isIOS && this.iosHandler) {
         console.log('[AudioHandler] Using iOS audio handler for microphone');
 
-        // First unlock audio context if needed
-        await this.iosHandler.unlockAudioContext();
+        await this.iosHandler.unlockAudioContext?.();
 
-        // Start microphone with iOS workarounds
-        const success = await this.iosHandler.startMicrophone((audioData) => {
+        const success = await this.iosHandler.startMicrophone?.((audioData) => {
           if (this.isStreaming) {
             this.emit('audioChunk', audioData);
           }
@@ -92,11 +106,10 @@ export class AudioHandler {
       this.stream = await navigator.mediaDevices.getUserMedia(constraints);
       console.log('Microphone access granted for continuous streaming');
 
-      // Create AudioContext for real-time processing
       this.audioContext = new (window.AudioContext ||
-        window.webkitAudioContext)();
+        (window as unknown as { webkitAudioContext: typeof AudioContext })
+          .webkitAudioContext)();
 
-      // Resume AudioContext if suspended (required on many browsers)
       if (this.audioContext.state === 'suspended') {
         console.log('Audio context suspended, resuming...');
         await this.audioContext.resume();
@@ -104,7 +117,7 @@ export class AudioHandler {
 
       this.microphone = this.audioContext.createMediaStreamSource(this.stream);
 
-      // Try AudioWorklet first, fallback to ScriptProcessorNode for iOS
+      // Try AudioWorklet first, fallback to ScriptProcessorNode
       if (this.audioContext.audioWorklet) {
         console.log('Setting up AudioWorklet processor...');
         await this.setupAudioWorklet();
@@ -121,9 +134,11 @@ export class AudioHandler {
     }
   }
 
-  async setupAudioWorklet() {
+  private async setupAudioWorklet(): Promise<void> {
+    if (!this.audioContext || !this.microphone) return;
+
     try {
-      await this.audioContext.audioWorklet.addModule('js/audio-processor.js');
+      await this.audioContext.audioWorklet.addModule('/audio-processor.js');
       console.log('AudioWorklet processor loaded');
 
       this.workletNode = new AudioWorkletNode(
@@ -136,9 +151,9 @@ export class AudioHandler {
         }
       );
 
-      this.workletNode.port.onmessage = (event) => {
+      this.workletNode.port.onmessage = (event: MessageEvent) => {
         if (this.isStreaming) {
-          const int16Buffer = event.data;
+          const int16Buffer = event.data as ArrayBuffer;
           const base64Audio = btoa(
             String.fromCharCode(...new Uint8Array(int16Buffer))
           );
@@ -146,7 +161,6 @@ export class AudioHandler {
         }
       };
 
-      // Connect the audio pipeline
       this.microphone.connect(this.workletNode);
       this.workletNode.connect(this.audioContext.destination);
     } catch (error) {
@@ -155,7 +169,9 @@ export class AudioHandler {
     }
   }
 
-  setupScriptProcessorNode() {
+  private setupScriptProcessorNode(): void {
+    if (!this.audioContext || !this.microphone) return;
+
     console.log('Setting up ScriptProcessorNode for compatibility...');
 
     const bufferSize = 4096;
@@ -167,11 +183,10 @@ export class AudioHandler {
 
     const targetSampleRate = 16000;
     const sourceSampleRate = this.audioContext.sampleRate;
-    // Maybe we should check if this equals 1 to not do the whole resampling
     const resampleRatio = sourceSampleRate / targetSampleRate;
-    let buffer = null;
+    let buffer: Float32Array | null = null;
 
-    this.scriptProcessor.onaudioprocess = (event) => {
+    this.scriptProcessor.onaudioprocess = (event: AudioProcessingEvent) => {
       if (this.isStreaming) {
         const inputData = event.inputBuffer.getChannelData(0);
 
@@ -184,7 +199,7 @@ export class AudioHandler {
         newBuffer.set(inputData, currentLength);
         buffer = newBuffer;
 
-        // Make it into 16k
+        // Resample to 16kHz
         const numOutputSamples = Math.floor(buffer.length / resampleRatio);
         if (numOutputSamples === 0) return;
 
@@ -202,7 +217,7 @@ export class AudioHandler {
             lowerValue + (upperValue - lowerValue) * interpolationFactor;
         }
 
-        // Save the remainder of the buffer for the next process call
+        // Save remainder for next process call
         const consumedInputSamples = numOutputSamples * resampleRatio;
         buffer = buffer.slice(Math.round(consumedInputSamples));
 
@@ -222,18 +237,17 @@ export class AudioHandler {
       }
     };
 
-    // Connect the audio pipeline
     this.microphone.connect(this.scriptProcessor);
     this.scriptProcessor.connect(this.audioContext.destination);
   }
 
-  stopStreaming() {
+  stopStreaming(): void {
     console.log('Stopping continuous audio streaming...');
     this.isStreaming = false;
 
     // Use iOS handler if available
     if (this.isIOS && this.iosHandler) {
-      this.iosHandler.stopMicrophone();
+      this.iosHandler.stopMicrophone?.();
       console.log('[AudioHandler] iOS microphone stopped');
       return;
     }
@@ -268,4 +282,8 @@ export class AudioHandler {
 
     console.log('Continuous audio streaming stopped');
   }
+
+  getIsStreaming(): boolean {
+    return this.isStreaming;
+  }
 }
diff --git a/frontend/js/audio-player.js b/frontend/src/services/AudioPlayer.ts
similarity index 54%
rename from frontend/js/audio-player.js
rename to frontend/src/services/AudioPlayer.ts
index fcd34b2..950fc82 100644
--- a/frontend/js/audio-player.js
+++ b/frontend/src/services/AudioPlayer.ts
@@ -1,16 +1,19 @@
+import type { IOSAudioHandler } from '../types';
+
+type EventCallback = () => void;
+
 export class AudioPlayer {
-  constructor() {
-    this.audioContext = null;
-    this.audioQueue = [];
-    this.isPlaying = false;
-    this.isStartingPlayback = false;
-    this.currentSource = null;
-    this.sampleRate = 16000; // Default sample rate to match backend
-    this.listeners = new Map();
-    this.isStreamingActive = false;
-    this.streamTimeout = null;
+  private audioContext: AudioContext | null = null;
+  private audioQueue: AudioBuffer[] = [];
+  private isPlaying = false;
+  private isStartingPlayback = false;
+  private currentSource: AudioBufferSourceNode | null = null;
+  private listeners = new Map<string, EventCallback[]>();
+  private streamTimeout: ReturnType<typeof setTimeout> | null = null;
+  private isIOS: boolean;
+  private iosHandler: IOSAudioHandler | null;
 
-    // Check for iOS and use iOS handler if available
+  constructor() {
     this.isIOS =
       /iPad|iPhone|iPod/.test(navigator.userAgent) ||
       (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
@@ -21,26 +24,26 @@ export class AudioPlayer {
     }
   }
 
-  on(event, callback) {
+  on(event: string, callback: EventCallback): void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, []);
     }
-    this.listeners.get(event).push(callback);
+    this.listeners.get(event)!.push(callback);
   }
 
-  emit(event, data) {
+  private emit(event: string): void {
     const callbacks = this.listeners.get(event);
     if (callbacks) {
-      callbacks.forEach((callback) => callback(data));
+      callbacks.forEach((callback) => callback());
     }
   }
 
-  async initialize() {
+  async initialize(): Promise<void> {
     try {
       this.audioContext = new (window.AudioContext ||
-        window.webkitAudioContext)();
+        (window as unknown as { webkitAudioContext: typeof AudioContext })
+          .webkitAudioContext)();
 
-      // Resume AudioContext if suspended
       if (this.audioContext.state === 'suspended') {
         await this.audioContext.resume();
       }
@@ -55,29 +58,29 @@ export class AudioPlayer {
     }
   }
 
-  async addAudioStream(base64Audio, sampleRate = 16000, isLastChunk = false, audioFormat = 'int16') {
+  async addAudioStream(
+    base64Audio: string,
+    sampleRate: number = 16000,
+    isLastChunk: boolean = false,
+    audioFormat: 'int16' | 'float32' = 'int16'
+  ): Promise<void> {
     if (!base64Audio || base64Audio.length === 0) {
       console.warn('Empty audio data received');
       return;
     }
 
-    // Mark streaming as active
-    this.isStreamingActive = true;
-
-    // Clear any existing timeout
     if (this.streamTimeout) {
       clearTimeout(this.streamTimeout);
     }
 
-    // Set a timeout to detect end of streaming (if no new chunks for 1 second)
     this.streamTimeout = setTimeout(() => {
       this.endStreaming();
     }, 1000);
 
-    // Use iOS handler for audio playback if available
+    // Use iOS handler if available
     if (this.isIOS && this.iosHandler) {
       try {
-        await this.iosHandler.playAudioChunk(base64Audio, isLastChunk);
+        await this.iosHandler.playAudioChunk?.(base64Audio, isLastChunk);
         if (!this.isPlaying) {
           this.isPlaying = true;
           this.emit('playback_started');
@@ -97,8 +100,6 @@ export class AudioPlayer {
     }
 
     try {
-      this.sampleRate = sampleRate;
-
       // Decode base64 to binary
       const binaryString = atob(base64Audio);
       const bytes = new Uint8Array(binaryString.length);
@@ -107,21 +108,18 @@ export class AudioPlayer {
         bytes[i] = binaryString.charCodeAt(i);
       }
 
-      // Create audio buffer from the decoded data
+      // Create audio buffer
       const audioBuffer = await this.createAudioBuffer(
         bytes.buffer,
         sampleRate,
         audioFormat
       );
 
-      // Queue the audio buffer for playback
       this.audioQueue.push(audioBuffer);
 
       // Start playback immediately if not already playing
-      // Use a flag to prevent race conditions
       if (!this.isPlaying && !this.isStartingPlayback) {
         this.isStartingPlayback = true;
-        // Use requestAnimationFrame for better timing
         requestAnimationFrame(() => {
           this.isStartingPlayback = false;
           this.playNextBuffer();
@@ -132,59 +130,66 @@ export class AudioPlayer {
     }
   }
 
-  async createAudioBuffer(arrayBuffer, sampleRate, audioFormat = 'int16') {
-    try {
-      let channelData;
-      let numSamples;
-
-      console.log(`[AudioPlayer] createAudioBuffer: format=${audioFormat}, byteLength=${arrayBuffer.byteLength}, sampleRate=${sampleRate}`);
-
-      if (audioFormat === 'float32') {
-        // Float32 PCM - bytes are IEEE 754 Float32 representation
-        // 4 bytes per sample, values already in [-1.0, 1.0] range
-        const float32Array = new Float32Array(arrayBuffer);
-        numSamples = float32Array.length;
-        console.log(`[AudioPlayer] Float32 samples: ${numSamples}, first 3 values: [${Array.from(float32Array.slice(0, 3)).map(v => v.toFixed(4)).join(', ')}]`);
-
-        const audioBuffer = this.audioContext.createBuffer(
-          1,
-          numSamples,
-          sampleRate
-        );
-        channelData = audioBuffer.getChannelData(0);
+  private async createAudioBuffer(
+    arrayBuffer: ArrayBuffer,
+    sampleRate: number,
+    audioFormat: 'int16' | 'float32' = 'int16'
+  ): Promise<AudioBuffer> {
+    if (!this.audioContext) {
+      throw new Error('Audio context not initialized');
+    }
 
-        for (let i = 0; i < numSamples; i++) {
-          channelData[i] = float32Array[i];
-        }
+    let numSamples: number;
 
-        return audioBuffer;
-      } else {
-        // Int16 PCM format - convert to Float32
-        const int16Array = new Int16Array(arrayBuffer);
-        numSamples = int16Array.length;
-        console.log(`[AudioPlayer] Int16 samples: ${numSamples}`);
-
-        const audioBuffer = this.audioContext.createBuffer(
-          1,
-          numSamples,
-          sampleRate
-        );
-        channelData = audioBuffer.getChannelData(0);
+    console.log(
+      `[AudioPlayer] createAudioBuffer: format=${audioFormat}, byteLength=${arrayBuffer.byteLength}, sampleRate=${sampleRate}`
+    );
 
-        for (let i = 0; i < numSamples; i++) {
-          channelData[i] = int16Array[i] / 32768.0;
-        }
+    if (audioFormat === 'float32') {
+      const float32Array = new Float32Array(arrayBuffer);
+      numSamples = float32Array.length;
+      console.log(
+        `[AudioPlayer] Float32 samples: ${numSamples}, first 3 values: [${Array.from(
+          float32Array.slice(0, 3)
+        )
+          .map((v) => v.toFixed(4))
+          .join(', ')}]`
+      );
+
+      const audioBuffer = this.audioContext.createBuffer(
+        1,
+        numSamples,
+        sampleRate
+      );
+      const channelData = audioBuffer.getChannelData(0);
 
-        return audioBuffer;
+      for (let i = 0; i < numSamples; i++) {
+        channelData[i] = float32Array[i];
       }
-    } catch (error) {
-      console.error('Error creating audio buffer:', error);
-      throw error;
+
+      return audioBuffer;
+    } else {
+      // Int16 PCM format
+      const int16Array = new Int16Array(arrayBuffer);
+      numSamples = int16Array.length;
+      console.log(`[AudioPlayer] Int16 samples: ${numSamples}`);
+
+      const audioBuffer = this.audioContext.createBuffer(
+        1,
+        numSamples,
+        sampleRate
+      );
+      const channelData = audioBuffer.getChannelData(0);
+
+      for (let i = 0; i < numSamples; i++) {
+        channelData[i] = int16Array[i] / 32768.0;
+      }
+
+      return audioBuffer;
     }
   }
 
-  playNextBuffer() {
-    // Prevent multiple simultaneous calls
+  private playNextBuffer(): void {
     if (this.isPlaying && this.currentSource) {
       return;
     }
@@ -195,24 +200,21 @@ export class AudioPlayer {
       return;
     }
 
-    const audioBuffer = this.audioQueue.shift();
+    if (!this.audioContext) return;
+
+    const audioBuffer = this.audioQueue.shift()!;
     this.isPlaying = true;
 
-    // Create buffer source
     this.currentSource = this.audioContext.createBufferSource();
     this.currentSource.buffer = audioBuffer;
 
-    // Connect to destination
     this.currentSource.connect(this.audioContext.destination);
 
-    // Set up event handlers
     this.currentSource.onended = () => {
       this.currentSource = null;
-      // Play next buffer in queue
       this.playNextBuffer();
     };
 
-    // Start playback
     try {
       this.currentSource.start(0);
       this.emit('playback_started');
@@ -221,15 +223,14 @@ export class AudioPlayer {
       console.error('Error starting audio playback:', error);
       this.currentSource = null;
       this.isPlaying = false;
-      // Try next buffer
       this.playNextBuffer();
     }
   }
 
-  stop() {
+  stop(): void {
     // Use iOS handler if available
     if (this.isIOS && this.iosHandler) {
-      this.iosHandler.stopAudioPlayback();
+      this.iosHandler.stopAudioPlayback?.();
       this.isPlaying = false;
       this.isStartingPlayback = false;
       this.emit('playback_stopped');
@@ -237,26 +238,23 @@ export class AudioPlayer {
     }
 
     // Standard implementation
-    // Stop current source first
     if (this.currentSource) {
       try {
         this.currentSource.stop();
         this.currentSource.disconnect();
         this.currentSource = null;
       } catch (error) {
-        // Source might already be stopped, ignore
         console.warn('Error stopping audio source:', error);
       }
     }
 
-    // Clear the queue and reset flags
     this.audioQueue = [];
     this.isPlaying = false;
     this.isStartingPlayback = false;
     this.emit('playback_stopped');
   }
 
-  destroy() {
+  destroy(): void {
     this.stop();
 
     if (this.audioContext) {
@@ -267,33 +265,29 @@ export class AudioPlayer {
     this.listeners.clear();
   }
 
-  getQueueLength() {
-    return this.audioQueue.length;
-  }
-
-  isPlaybackActive() {
-    return this.isPlaying;
-  }
-
-  endStreaming() {
+  private endStreaming(): void {
     console.log('[AudioPlayer] Stream ended, finalizing audio playback');
-    this.isStreamingActive = false;
 
-    // Clear timeout
     if (this.streamTimeout) {
       clearTimeout(this.streamTimeout);
       this.streamTimeout = null;
     }
 
-    // For iOS, signal that streaming is complete
     if (this.isIOS && this.iosHandler) {
-      this.iosHandler.playAudioChunk('', true); // Send empty chunk with isLastChunk=true
+      this.iosHandler.playAudioChunk?.('', true);
     }
   }
 
-  // Method to be called when backend signals stream complete
-  markStreamComplete() {
+  markStreamComplete(): void {
     console.log('[AudioPlayer] Stream marked as complete by backend');
     this.endStreaming();
   }
+
+  getQueueLength(): number {
+    return this.audioQueue.length;
+  }
+
+  isPlaybackActive(): boolean {
+    return this.isPlaying;
+  }
 }
diff --git a/frontend/js/storage.js b/frontend/src/services/Storage.ts
similarity index 70%
rename from frontend/js/storage.js
rename to frontend/src/services/Storage.ts
index de011a8..7ac61b1 100644
--- a/frontend/js/storage.js
+++ b/frontend/src/services/Storage.ts
@@ -1,13 +1,31 @@
+import type { Flashcard, ConversationHistory } from '../types';
+
 export class Storage {
-  constructor() {
-    this.storageKey = 'aprende-app-state';
-    this.conversationKey = 'aprende-conversation-history';
-    this.flashcardsKey = 'aprende-flashcards';
-    this.languageKey = 'aprende-language';
+  private storageKey = 'aprende-app-state';
+  private conversationKey = 'aprende-conversation-history';
+  private flashcardsKey = 'aprende-flashcards';
+  private languageKey = 'aprende-language';
+  private userIdKey = 'aprende-user-id';
+
+  // User ID methods
+  getOrCreateUserId(): string {
+    try {
+      let id = localStorage.getItem(this.userIdKey);
+      if (!id) {
+        id =
+          typeof crypto !== 'undefined' && crypto.randomUUID
+            ? crypto.randomUUID()
+            : `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        localStorage.setItem(this.userIdKey, id);
+      }
+      return id;
+    } catch {
+      return `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    }
   }
 
   // Language preference methods
-  getLanguage() {
+  getLanguage(): string {
     try {
       return localStorage.getItem(this.languageKey) || 'es';
     } catch (error) {
@@ -16,7 +34,7 @@ export class Storage {
     }
   }
 
-  saveLanguage(languageCode) {
+  saveLanguage(languageCode: string): void {
     try {
       localStorage.setItem(this.languageKey, languageCode);
     } catch (error) {
@@ -24,7 +42,8 @@ export class Storage {
     }
   }
 
-  saveState(state) {
+  // State methods
+  saveState(state: { chatHistory: unknown[] }): void {
     try {
       const serializedState = JSON.stringify(state);
       localStorage.setItem(this.storageKey, serializedState);
@@ -33,7 +52,7 @@ export class Storage {
     }
   }
 
-  getState() {
+  getState(): { chatHistory: unknown[] } | null {
     try {
       const serializedState = localStorage.getItem(this.storageKey);
       if (serializedState === null) {
@@ -46,16 +65,8 @@ export class Storage {
     }
   }
 
-  clearState() {
-    try {
-      localStorage.removeItem(this.storageKey);
-    } catch (error) {
-      console.error('Failed to clear state from localStorage:', error);
-    }
-  }
-
   // Conversation history methods
-  getConversationHistory() {
+  getConversationHistory(): ConversationHistory {
     try {
       const serializedHistory = localStorage.getItem(this.conversationKey);
       if (serializedHistory === null) {
@@ -71,24 +82,22 @@ export class Storage {
     }
   }
 
-  addMessage(role, content) {
+  addMessage(role: 'user' | 'assistant', content: string): ConversationHistory {
     const history = this.getConversationHistory();
 
-    // Add new message with timestamp
     const message = {
-      role: role,
-      content: content,
+      role,
+      content,
       timestamp: new Date().toISOString(),
     };
 
     history.messages.push(message);
 
-    // Truncate to keep only last 40 turns (80 messages: 40 user + 40 assistant)
+    // Truncate to keep only last 40 turns (80 messages)
     if (history.messages.length > 80) {
       history.messages = history.messages.slice(-80);
     }
 
-    // Save updated history
     try {
       const serializedHistory = JSON.stringify(history);
       localStorage.setItem(this.conversationKey, serializedHistory);
@@ -102,7 +111,7 @@ export class Storage {
     return history;
   }
 
-  clearConversation() {
+  clearConversation(): void {
     try {
       localStorage.removeItem(this.conversationKey);
     } catch (error) {
@@ -113,25 +122,24 @@ export class Storage {
     }
   }
 
-  // Flashcard methods - now support per-language storage
-  _getFlashcardsKey(languageCode) {
+  // Flashcard methods
+  private getFlashcardsKey(languageCode?: string): string {
     if (!languageCode) {
       return this.flashcardsKey;
     }
     return `${this.flashcardsKey}-${languageCode}`;
   }
 
-  getFlashcards(languageCode) {
+  getFlashcards(languageCode: string): Flashcard[] {
     try {
-      const key = this._getFlashcardsKey(languageCode);
+      const key = this.getFlashcardsKey(languageCode);
       const serializedFlashcards = localStorage.getItem(key);
       if (serializedFlashcards === null) {
         // Try to migrate from old format if no language-specific data exists
         if (languageCode === 'es') {
           const oldFlashcards = localStorage.getItem(this.flashcardsKey);
           if (oldFlashcards) {
-            const parsed = JSON.parse(oldFlashcards);
-            // Migrate old flashcards to new format
+            const parsed = JSON.parse(oldFlashcards) as Flashcard[];
             const migrated = parsed.map((card) => ({
               ...card,
               targetWord: card.targetWord || card.spanish || '',
@@ -150,9 +158,9 @@ export class Storage {
     }
   }
 
-  saveFlashcards(flashcards, languageCode) {
+  saveFlashcards(flashcards: Flashcard[], languageCode: string): void {
     try {
-      const key = this._getFlashcardsKey(languageCode);
+      const key = this.getFlashcardsKey(languageCode);
       const serializedFlashcards = JSON.stringify(flashcards);
       localStorage.setItem(key, serializedFlashcards);
     } catch (error) {
@@ -160,10 +168,10 @@ export class Storage {
     }
   }
 
-  addFlashcards(newFlashcards, languageCode) {
+  addFlashcards(newFlashcards: Flashcard[], languageCode: string): Flashcard[] {
     const existingFlashcards = this.getFlashcards(languageCode);
 
-    // Filter out duplicates based on targetWord (backwards compatible with spanish)
+    // Filter out duplicates
     const uniqueNewFlashcards = newFlashcards.filter((newCard) => {
       const newWord = newCard.targetWord || newCard.spanish || '';
       return !existingFlashcards.some((existing) => {
@@ -176,7 +184,7 @@ export class Storage {
     const flashcardsWithLanguage = uniqueNewFlashcards.map((card) => ({
       ...card,
       targetWord: card.targetWord || card.spanish || '',
-      languageCode: languageCode,
+      languageCode,
     }));
 
     const updatedFlashcards = [...existingFlashcards, ...flashcardsWithLanguage];
@@ -190,27 +198,12 @@ export class Storage {
     return updatedFlashcards;
   }
 
-  clearFlashcards(languageCode) {
+  clearFlashcards(languageCode: string): void {
     try {
-      const key = this._getFlashcardsKey(languageCode);
+      const key = this.getFlashcardsKey(languageCode);
       localStorage.removeItem(key);
     } catch (error) {
       console.error('Failed to clear flashcards from localStorage:', error);
     }
   }
-
-  // Clear all flashcards for all languages
-  clearAllFlashcards() {
-    try {
-      // Clear the base key
-      localStorage.removeItem(this.flashcardsKey);
-      // Clear language-specific keys
-      const languages = ['es', 'ja', 'fr'];
-      languages.forEach((lang) => {
-        localStorage.removeItem(this._getFlashcardsKey(lang));
-      });
-    } catch (error) {
-      console.error('Failed to clear all flashcards from localStorage:', error);
-    }
-  }
 }
diff --git a/frontend/js/translator.js b/frontend/src/services/Translator.ts
similarity index 53%
rename from frontend/js/translator.js
rename to frontend/src/services/Translator.ts
index 5045f02..9cc9fe6 100644
--- a/frontend/js/translator.js
+++ b/frontend/src/services/Translator.ts
@@ -1,45 +1,36 @@
-/**
- * Translation service using Google's free translation endpoint
- * No authentication required
- */
 export class Translator {
-  constructor() {
-    this.cache = new Map();
-    this.pendingRequests = new Map();
-  }
+  private cache = new Map<string, string>();
+  private pendingRequests = new Map<string, Promise<string>>();
 
-  /**
-   * Translate text to target language using Google's free endpoint
-   * @param {string} text - Text to translate
-   * @param {string} targetLang - Target language code (default: 'en')
-   * @param {string} sourceLang - Source language code (default: 'auto' for auto-detect)
-   * @returns {Promise<string>} - Translated text
-   */
-  async translate(text, targetLang = 'en', sourceLang = 'auto') {
+  async translate(
+    text: string,
+    targetLang: string = 'en',
+    sourceLang: string = 'auto'
+  ): Promise<string> {
     if (!text || !text.trim()) {
       return '';
     }
 
     const cacheKey = `${sourceLang}:${targetLang}:${text}`;
-    
+
     // Check cache first
     if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey);
+      return this.cache.get(cacheKey)!;
     }
 
-    // Check if there's already a pending request for this text
+    // Check if there's already a pending request
     if (this.pendingRequests.has(cacheKey)) {
-      return this.pendingRequests.get(cacheKey);
+      return this.pendingRequests.get(cacheKey)!;
     }
 
     // Create the translation request
-    const requestPromise = this._fetchTranslation(text, targetLang, sourceLang)
-      .then(translation => {
+    const requestPromise = this.fetchTranslation(text, targetLang, sourceLang)
+      .then((translation) => {
         this.cache.set(cacheKey, translation);
         this.pendingRequests.delete(cacheKey);
         return translation;
       })
-      .catch(error => {
+      .catch((error) => {
         this.pendingRequests.delete(cacheKey);
         throw error;
       });
@@ -48,25 +39,28 @@ export class Translator {
     return requestPromise;
   }
 
-  async _fetchTranslation(text, targetLang, sourceLang) {
+  private async fetchTranslation(
+    text: string,
+    targetLang: string,
+    sourceLang: string
+  ): Promise<string> {
     const encodedText = encodeURIComponent(text);
     const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${sourceLang}&tl=${targetLang}&dt=t&q=${encodedText}`;
 
     try {
       const response = await fetch(url);
-      
+
       if (!response.ok) {
         throw new Error(`Translation failed: ${response.status}`);
       }
 
       const data = await response.json();
-      
+
       // Google's response format: [[["translated text", "original text", ...], ...], ...]
-      // We need to concatenate all translated segments
       if (data && data[0]) {
         const translatedParts = data[0]
-          .filter(part => part && part[0])
-          .map(part => part[0]);
+          .filter((part: unknown[]) => part && part[0])
+          .map((part: unknown[]) => part[0]);
         return translatedParts.join('');
       }
 
@@ -77,14 +71,7 @@ export class Translator {
     }
   }
 
-  /**
-   * Clear the translation cache
-   */
-  clearCache() {
+  clearCache(): void {
     this.cache.clear();
   }
 }
-
-// Singleton instance
-export const translator = new Translator();
-
diff --git a/frontend/js/websocket-client.js b/frontend/src/services/WebSocketClient.ts
similarity index 56%
rename from frontend/js/websocket-client.js
rename to frontend/src/services/WebSocketClient.ts
index 200d0da..fa200a7 100644
--- a/frontend/js/websocket-client.js
+++ b/frontend/src/services/WebSocketClient.ts
@@ -1,20 +1,30 @@
+import type { Flashcard } from '../types';
+
+type EventCallback = (data: unknown) => void;
+
 export class WebSocketClient {
-  constructor(url) {
+  private url: string;
+  private ws: WebSocket | null = null;
+  private listeners = new Map<string, EventCallback[]>();
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+  private reconnectDelay = 1000;
+  private pingInterval: ReturnType<typeof setInterval> | null = null;
+  private isIOS: boolean;
+  private isConnecting = false;
+  private isIntentionalDisconnect = false;
+  private connectionId = 0; // Track current connection to ignore stale handlers
+
+  constructor(url: string) {
     this.url = url;
-    this.ws = null;
-    this.listeners = new Map();
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    this.reconnectDelay = 1000;
-    this.pingInterval = null;
-
-    // Check for iOS and use optimized URL if available
+
+    // Check for iOS
     this.isIOS =
       /iPad|iPhone|iPod/.test(navigator.userAgent) ||
       (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
 
     if (this.isIOS && window.iosAudioHandler) {
-      const optimizedUrl = window.iosAudioHandler.getOptimizedWebSocketURL();
+      const optimizedUrl = window.iosAudioHandler.getOptimizedWebSocketURL?.();
       if (optimizedUrl) {
         console.log(
           '[WebSocketClient] Using iOS-optimized WebSocket URL:',
@@ -25,31 +35,72 @@ export class WebSocketClient {
     }
   }
 
-  on(event, callback) {
+  on(event: string, callback: EventCallback): void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, []);
     }
-    this.listeners.get(event).push(callback);
+    this.listeners.get(event)!.push(callback);
   }
 
-  emit(event, data) {
+  off(event: string, callback: EventCallback): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  clearAllListeners(): void {
+    this.listeners.clear();
+  }
+
+  isConnected(): boolean {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+
+  private emit(event: string, data?: unknown): void {
     const callbacks = this.listeners.get(event);
     if (callbacks) {
       callbacks.forEach((callback) => callback(data));
     }
   }
 
-  async connect() {
+  async connect(): Promise<void> {
+    // Prevent duplicate connections
+    if (this.isConnecting) {
+      console.log('[WebSocketClient] Connection already in progress, skipping');
+      return Promise.resolve();
+    }
+    if (this.isConnected()) {
+      console.log('[WebSocketClient] Already connected, skipping');
+      return Promise.resolve();
+    }
+
+    this.isConnecting = true;
+    this.isIntentionalDisconnect = false;
+
+    // Increment connection ID - this allows us to ignore handlers from stale connections
+    const thisConnectionId = ++this.connectionId;
+
     return new Promise((resolve, reject) => {
       try {
         this.ws = new WebSocket(this.url);
 
         this.ws.onopen = () => {
+          // Ignore if this is a stale connection
+          if (thisConnectionId !== this.connectionId) {
+            console.log('[WebSocketClient] Ignoring onopen from stale connection');
+            return;
+          }
+
           console.log('WebSocket connected');
+          this.isConnecting = false;
           this.reconnectAttempts = 0;
           this.emit('connection', 'connected');
 
-          // Start ping/pong for iOS to keep connection alive
+          // Start ping/pong for iOS
           if (this.isIOS) {
             this.startPingPong();
           }
@@ -57,7 +108,12 @@ export class WebSocketClient {
           resolve();
         };
 
-        this.ws.onmessage = (event) => {
+        this.ws.onmessage = (event: MessageEvent) => {
+          // Ignore messages from stale connections
+          if (thisConnectionId !== this.connectionId) {
+            return;
+          }
+
           try {
             const message = JSON.parse(event.data);
             this.handleMessage(message);
@@ -66,14 +122,22 @@ export class WebSocketClient {
           }
         };
 
-        this.ws.onclose = (event) => {
+        this.ws.onclose = (event: CloseEvent) => {
+          // Ignore if this is a stale connection
+          if (thisConnectionId !== this.connectionId) {
+            console.log('[WebSocketClient] Ignoring onclose from stale connection');
+            return;
+          }
+
           console.log('WebSocket disconnected:', event.code, event.reason);
+          this.isConnecting = false;
           this.emit('connection', 'disconnected');
 
-          // Stop ping/pong
           this.stopPingPong();
 
+          // Only attempt reconnect if not intentionally disconnected
           if (
+            !this.isIntentionalDisconnect &&
             !event.wasClean &&
             this.reconnectAttempts < this.maxReconnectAttempts
           ) {
@@ -82,19 +146,28 @@ export class WebSocketClient {
         };
 
         this.ws.onerror = (error) => {
+          // Ignore if this is a stale connection
+          if (thisConnectionId !== this.connectionId) {
+            console.log('[WebSocketClient] Ignoring onerror from stale connection');
+            return;
+          }
+
           console.error('WebSocket error:', error);
+          this.isConnecting = false;
           this.emit('connection', 'disconnected');
           reject(error);
         };
       } catch (error) {
+        this.isConnecting = false;
         reject(error);
       }
     });
   }
 
-  scheduleReconnect() {
+  private scheduleReconnect(): void {
     this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    const delay =
+      this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
 
     console.log(
       `Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
@@ -111,10 +184,10 @@ export class WebSocketClient {
     }, delay);
   }
 
-  handleMessage(message) {
+  private handleMessage(message: { type: string; [key: string]: unknown }): void {
     switch (message.type) {
       case 'transcript_update':
-        this.emit('transcript_update', message.data.text);
+        this.emit('transcript_update', (message.data as { text: string }).text);
         break;
 
       case 'transcription':
@@ -126,8 +199,8 @@ export class WebSocketClient {
 
       case 'ai_response':
         this.emit('ai_response', {
-          text: message.data.text,
-          audio: message.data.audio,
+          text: (message.data as { text: string }).text,
+          audio: (message.data as { audio?: string }).audio,
         });
         break;
 
@@ -136,8 +209,9 @@ export class WebSocketClient {
         break;
 
       case 'flashcards_generated':
-        this.emit('flashcards_generated', message.flashcards);
+        this.emit('flashcards_generated', message.flashcards as Flashcard[]);
         break;
+
       case 'introduction_state_updated':
         this.emit('introduction_state_updated', message.introduction_state);
         break;
@@ -195,18 +269,25 @@ export class WebSocketClient {
         this.emit('interrupt', { reason: message.reason });
         break;
 
+      case 'language_changed':
+        this.emit('language_changed', {
+          languageCode: message.languageCode,
+          languageName: message.languageName,
+        });
+        break;
+
       default:
         console.log('Unknown message type:', message.type);
     }
   }
 
-  send(message) {
+  send(message: { type: string; [key: string]: unknown }): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(message));
     }
   }
 
-  sendAudioChunk(audioData) {
+  sendAudioChunk(audioData: string): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       const message = {
         type: 'audio_chunk',
@@ -216,15 +297,17 @@ export class WebSocketClient {
     }
   }
 
-  disconnect() {
+  disconnect(): void {
+    this.isIntentionalDisconnect = true;
+    this.isConnecting = false;
     this.stopPingPong();
     if (this.ws) {
       this.ws.close();
+      this.ws = null;
     }
   }
 
-  startPingPong() {
-    // Send ping every 30 seconds to keep connection alive on iOS
+  private startPingPong(): void {
     this.pingInterval = setInterval(() => {
       if (this.ws && this.ws.readyState === WebSocket.OPEN) {
         this.send({ type: 'ping' });
@@ -233,7 +316,7 @@ export class WebSocketClient {
     }, 30000);
   }
 
-  stopPingPong() {
+  private stopPingPong(): void {
     if (this.pingInterval) {
       clearInterval(this.pingInterval);
       this.pingInterval = null;
diff --git a/frontend/styles/main.css b/frontend/src/styles/main.css
similarity index 100%
rename from frontend/styles/main.css
rename to frontend/src/styles/main.css
diff --git a/frontend/src/types/global.d.ts b/frontend/src/types/global.d.ts
new file mode 100644
index 0000000..e5a328f
--- /dev/null
+++ b/frontend/src/types/global.d.ts
@@ -0,0 +1,11 @@
+// Global type declarations for Window interface
+
+import type { IOSAudioHandler } from './index';
+
+declare global {
+  interface Window {
+    iosAudioHandler?: IOSAudioHandler;
+  }
+}
+
+export {};
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
new file mode 100644
index 0000000..64646c6
--- /dev/null
+++ b/frontend/src/types/index.ts
@@ -0,0 +1,139 @@
+// iOS Audio Handler interface
+export interface IOSAudioHandler {
+  unlockAudioContext?: () => Promise<void>;
+  startMicrophone?: (callback: (data: string) => void) => Promise<boolean>;
+  stopMicrophone?: () => void;
+  playAudioChunk?: (data: string, isLastChunk: boolean) => Promise<void>;
+  stopAudioPlayback?: () => void;
+  getOptimizedWebSocketURL?: () => string | null;
+}
+
+// Connection status
+export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
+
+// Message role
+export type MessageRole = 'learner' | 'teacher';
+
+// Chat message for UI display
+export interface ChatMessage {
+  role: MessageRole;
+  content: string;
+  timestamp?: string;
+}
+
+// Conversation message for backend
+export interface ConversationMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: string;
+}
+
+export interface ConversationHistory {
+  messages: ConversationMessage[];
+}
+
+// Flashcard
+export interface Flashcard {
+  targetWord: string;
+  english: string;
+  example: string;
+  mnemonic: string;
+  timestamp?: string;
+  languageCode?: string;
+  // Legacy fields for backward compatibility
+  spanish?: string;
+  word?: string;
+  translation?: string;
+  example_sentence?: string;
+}
+
+// Language
+export interface Language {
+  code: string;
+  name: string;
+  nativeName: string;
+  flag: string;
+}
+
+// Audio stream data
+export interface AudioStreamData {
+  audio: string;
+  audioFormat: 'int16' | 'float32';
+  sampleRate: number;
+  timestamp?: string;
+  text?: string;
+}
+
+// WebSocket event payloads
+export interface TranscriptUpdatePayload {
+  text: string;
+}
+
+export interface TranscriptionPayload {
+  text: string;
+  timestamp?: string;
+}
+
+export interface LLMResponseChunkPayload {
+  text: string;
+  timestamp?: string;
+}
+
+export interface LLMResponseCompletePayload {
+  text: string;
+  timestamp?: string;
+}
+
+export interface SpeechDetectedPayload {
+  text?: string;
+  interactionId?: string;
+}
+
+export interface PartialTranscriptPayload {
+  text: string;
+  interactionId?: string;
+  timestamp?: string;
+}
+
+export interface InterruptPayload {
+  reason?: string;
+}
+
+export interface LanguageChangedPayload {
+  languageCode: string;
+  languageName: string;
+}
+
+// App state
+export interface AppState {
+  // Connection
+  connectionStatus: ConnectionStatus;
+
+  // Language
+  currentLanguage: string;
+  availableLanguages: Language[];
+
+  // Chat
+  chatHistory: ChatMessage[];
+  currentTranscript: string;
+  pendingTranscription: string | null;
+  streamingLLMResponse: string;
+  llmResponseComplete: boolean;
+  currentResponseId: string | null;
+
+  // Recording
+  isRecording: boolean;
+  speechDetected: boolean;
+
+  // Flashcards
+  flashcards: Flashcard[];
+
+  // User
+  userId: string;
+}
+
+// Outgoing WebSocket message
+export interface OutgoingMessage {
+  type: string;
+  [key: string]: unknown;
+}
diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts
new file mode 100644
index 0000000..11f02fe
--- /dev/null
+++ b/frontend/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
new file mode 100644
index 0000000..a9b5a59
--- /dev/null
+++ b/frontend/tsconfig.app.json
@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/frontend/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json
new file mode 100644
index 0000000..8a67f62
--- /dev/null
+++ b/frontend/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
new file mode 100644
index 0000000..d974908
--- /dev/null
+++ b/frontend/vite.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3000',
+        changeOrigin: true,
+      },
+    },
+  },
+})
diff --git a/realtime-service/.env-sample b/realtime-service/.env-sample
deleted file mode 100644
index ffdcd2e..0000000
--- a/realtime-service/.env-sample
+++ /dev/null
@@ -1,39 +0,0 @@
-# DO NOT EDIT THIS FILE DIRECTLY
-# Copy this file to .env and enter your own values
-#
-# INWORLD_API_KEY is required
-INWORLD_API_KEY=
-# ASSEMBLYAI_API_KEY is required for audio transcription
-ASSEMBLYAI_API_KEY=
-# VAD_MODEL_PATH is optional, defaults to packaged https://github.com/snakers4/silero-vad
-VAD_MODEL_PATH=
-# LLM_MODEL_NAME is optional, defaults to `gpt-4o-mini`
-LLM_MODEL_NAME=
-# LLM_PROVIDER is optional, defaults to `openai`
-LLM_PROVIDER=
-# VOICE_ID is optional, defaults to `Dennis`
-VOICE_ID=
-# TTS_MODEL_ID is optional, defaults to `inworld-tts-1`
-TTS_MODEL_ID=
-# If enabled, it will be saved in system tmp folder.
-# Path will be printed in CLI on application start.
-# Default value is `false`, set `true` to enable this feature
-GRAPH_VISUALIZATION_ENABLED=
-# If enabled, the user can stop the agent's audio playback with
-# text or speech input. For speech input use case, users could accidentally interrupt
-# in the case of false postivie speech detection. You can tune the following parameters
-# to achieve the right level of speech detection sensitivy for your application:
-# MIN_SPEECH_DURATION_MS, PAUSE_DURATION_THRESHOLD_MS, SPEECH_THRESHOLD
-# AUTH_TOKEN is optional, but recommended for basic security.
-# If set, clients must provide this token in the Authorization header.
-AUTH_TOKEN=
-
-# Logging configuration
-# REALTIME_LOG_LEVEL: 'debug', 'info', 'warn', 'error' (default: 'info')
-# REALTIME_LOG_PRETTY: '1' to enable pretty logs locally (default: '0' = JSON)
-# Examples:
-#   npm start                              # JSON logs (default, cloud-ready)
-#   REALTIME_LOG_PRETTY=1 npm start        # Pretty logs (local dev)
-#   REALTIME_LOG_LEVEL=debug npm start     # JSON with debug level
-REALTIME_LOG_LEVEL=info
-REALTIME_LOG_PRETTY=1
\ No newline at end of file
diff --git a/realtime-service/Makefile b/realtime-service/Makefile
deleted file mode 100644
index 711dd59..0000000
--- a/realtime-service/Makefile
+++ /dev/null
@@ -1,53 +0,0 @@
-.PHONY: build docker-build docker-run local-install local-start local-build help
-
-# Docker image name
-IMAGE_NAME ?= oai-realtime-api-voice-agent
-IMAGE_TAG ?= latest
-
-GH_TOKEN ?=
-
-# Default target
-help:
-	@echo "Available commands:"
-	@echo "  make docker-build    - Build Docker image"
-	@echo "  make docker-run      - Run Docker container"
-	@echo "  make local-install   - Install dependencies locally"
-	@echo "  make local-start     - Start server locally (development mode)"
-	@echo "  make local-build     - Build TypeScript project locally"
-	@echo "  make help           - Show this help message"
-	@echo ""
-	@echo "Note: For docker-build, you can set GITHUB_TOKEN environment variable"
-	@echo "      to download @inworld/runtime binaries from GitHub:"
-	@echo "      GH_TOKEN=your_token make docker-build"
-
-# Build Docker image
-docker-build:
-	@echo "Building Docker image: $(IMAGE_NAME):$(IMAGE_TAG)"
-	@if [ -n "$(GH_TOKEN)" ]; then \
-		echo "Using GH_TOKEN for downloading binaries..."; \
-		docker build --platform linux/amd64 --build-arg GH_TOKEN=$(GH_TOKEN) --build-arg SERVICE_PATH=serving/realtime-service --build-arg SERVICE_PORT=4000 -t $(IMAGE_NAME):$(IMAGE_TAG) -f ../../.github/builds/Dockerfile.node-service.common ../..; \
-	else \
-		echo "Warning: GH_TOKEN not set. Build may fail if @inworld/runtime binaries require authentication."; \
-		docker build --platform linux/amd64 --build-arg SERVICE_PATH=serving/realtime-service --build-arg SERVICE_PORT=4000 -t $(IMAGE_NAME):$(IMAGE_TAG) -f ../../.github/builds/Dockerfile.node-service.common ../..; \
-	fi
-
-# Run Docker container
-docker-run:
-	@echo "Running Docker container: $(IMAGE_NAME):$(IMAGE_TAG)"
-	docker run --platform linux/amd64 -p 4000:4000 -p 9000:9000 --env-file .env -e LLM_PROVIDER=groq -e LLM_MODEL_NAME=llama-3.3-70b-versatile $(IMAGE_NAME):$(IMAGE_TAG)
-
-# Install dependencies locally
-local-install:
-	@echo "Installing dependencies..."
-	cd server && npm install
-
-# Build TypeScript project locally
-local-build:
-	@echo "Building TypeScript project..."
-	cd server && npm run build
-
-# Start server locally (development mode with nodemon)
-local-start: local-install
-	@echo "Starting server locally..."
-	cd server && npm start
-
diff --git a/realtime-service/README.md b/realtime-service/README.md
deleted file mode 100644
index 7ba1c04..0000000
--- a/realtime-service/README.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Inworld Realtime Service
-
-This is an Inworld service that implements a web-sockets OpenAI Realtime API compatible API.
-
-## Building and Running with Docker
-
-### Build Docker Image
-
-```bash
-make docker-build
-```
-
-Optionally, you can provide a GitHub token to download `@inworld/runtime` binaries:
-
-```bash
-GH_TOKEN=your_token make docker-build
-```
-
-### Run Docker Container
-
-```bash
-make docker-run
-```
-
-This will run the container on port 4000. Make sure you have a `.env` file in the root directory with the required environment variables.
-
-## Building and Running without Docker
-
-### Install Dependencies
-
-```bash
-cd src
-npm install
-```
-
-### Build Project
-
-```bash
-cd src
-npm run build
-```
-
-### Run the Server
-
-For development (with nodemon):
-
-```bash
-cd src
-npm start
-```
-
-The server will start on port 4000 by default (or the port specified in your environment variables).
-
-## Configuration
-
-### Logging
-
-The service outputs JSON logs by default (Google Cloud Logging compatible).
-
-**Environment Variables:**
-- `REALTIME_LOG_LEVEL` - Log level: `debug`, `info`, `warn`, `error` (default: `info`)
-- `REALTIME_LOG_PRETTY` - Set to `1` for human-readable logs during development (default: `0` = JSON)
-
-**Examples:**
-```bash
-npm start                                      # JSON logs (production-ready)
-REALTIME_LOG_PRETTY=1 npm start                # Pretty logs (local dev)
-REALTIME_LOG_LEVEL=debug npm start             # JSON with debug level
-REALTIME_LOG_PRETTY=1 REALTIME_LOG_LEVEL=debug npm start  # Pretty with debug level
-```
-
-See [LOGGING.md](LOGGING.md) for detailed logging best practices.
-
-## Test websocket connection
-### Locally running w-proxy and realtime service
-```
-ws://localhost:8081/api/v1/realtime/session?key=<session-id>&protocol=realtime
-```
-with Authorization header
-
-### Dev: running w-proxy and realtime service
-```
-wss://api.dev.inworld.ai:443/api/v1/realtime/session?key=<session-id>&protocol=realtime
-```
-with Authorization header
-
-### Dev: tailscale and directly to realtime service
-```
-ws://realtime-service-dev.tail4c73a.ts.net:4000/session?key=<session-id>&protocol=realtime
-```
-no need to provide Authorization header (debug only)
diff --git a/realtime-service/__tests__/README.md b/realtime-service/__tests__/README.md
deleted file mode 100644
index 1ba3380..0000000
--- a/realtime-service/__tests__/README.md
+++ /dev/null
@@ -1,469 +0,0 @@
-# Realtime Service Tests
-
-Comprehensive API-level integration tests for the OpenAI Realtime API WebSocket service.
-
-## Quick Start
-
-### 1. Install Dependencies
-```bash
-npm install
-```
-
-### 2. Start Server (Terminal 1)
-```bash
-cd src && npm start
-```
-Wait for: `Application Server listening on port 4000`
-
-### 3. Run Tests (Terminal 2)
-```bash
-npm test
-```
-
-That's it! ✅
-
-> **TL;DR:** See [`SIMPLE_START.md`](./SIMPLE_START.md) for the absolute quickest guide.
-
----
-
-## Table of Contents
-
-- [What We Test](#what-we-test)
-- [Running Tests](#running-tests)
-- [Writing Tests](#writing-tests)
-- [Test Utilities](#test-utilities)
-- [Troubleshooting](#troubleshooting)
-- [Why API Tests Only](#why-api-tests-only)
-- [CI/CD Integration](#cicd-integration)
-
----
-
-## What We Test
-
-We use **API-level integration tests** that validate complete WebSocket behavior:
-
-✅ **Session Management** (3 tests) - Creation, configuration, turn detection  
-✅ **Conversation Management** (5 tests) - CRUD operations on items  
-✅ **Response Generation** (4 tests) - Complete response lifecycle  
-✅ **Function Calling** (1 test) - Tool execution  
-✅ **Audio Input** (1 test) - Buffer operations  
-✅ **Error Handling** (2 tests) - Invalid requests  
-✅ **Multi-Session** (1 test) - Concurrent sessions  
-✅ **Workspace Isolation** (1 test) - Multi-tenancy  
-
-**Total: 18 passing tests, 1 skipped** (~6 seconds runtime)
-
----
-
-## Running Tests
-
-### Basic Commands
-
-```bash
-# Run all tests (requires server running)
-npm test
-
-# Run in watch mode
-npm run test:watch
-
-# Run with coverage report
-npm run test:coverage
-
-# Run specific test
-npm test -- -t "should create a session"
-```
-
-### Environment Variables
-
-Optionally create `.env.test` in the project root:
-
-```bash
-INWORLD_API_KEY=your-api-key
-WORKSPACE_ID=your-workspace-id
-```
-
-**Note:** `WS_APP_PORT` is automatically managed by tests - they find an available port dynamically.
-
----
-
-## Writing Tests
-
-### Test Structure
-
-```typescript
-import { v4 as uuidv4 } from 'uuid';
-import { createWebSocketTestClient, createTextMessage } from './websocket-test-helper';
-
-it('should test some API behavior', async () => {
-  // 1. Create client with unique session ID
-  const sessionKey = `test-session-${uuidv4()}`;
-  const client = await createWebSocketTestClient(sessionKey, 4000);
-  
-  try {
-    // 2. Wait for session initialization
-    await client.waitForEvent('session.created');
-    
-    // 3. Send client event
-    client.sendEvent({
-      type: 'conversation.item.create',
-      item: createTextMessage('Hello, world!'),
-    });
-    
-    // 4. Verify server response
-    const addedEvent = await client.waitForEvent('conversation.item.added');
-    expect(addedEvent.item.content[0].text).toBe('Hello, world!');
-    
-  } finally {
-    // 5. Always clean up
-    await client.close();
-  }
-});
-```
-
-### Best Practices
-
-✅ **Use unique session IDs** - `uuidv4()` for each test  
-✅ **Always close connections** - Use try/finally blocks  
-✅ **Set appropriate timeouts** - Default is 5000ms, adjust if needed  
-✅ **Test both success and errors** - Don't just test happy paths  
-✅ **Keep tests independent** - No shared state between tests  
-
----
-
-## Test Utilities
-
-### Creating a Test Client
-
-```typescript
-const client = await createWebSocketTestClient(
-  'session-123',  // session key
-  4000,           // port (optional, defaults to 3001)
-  'workspace-id'  // workspace ID (optional)
-);
-```
-
-### Waiting for Events
-
-```typescript
-// Wait for single event
-const event = await client.waitForEvent('session.created', 5000);
-
-// Wait for multiple events in sequence
-const [event1, event2] = await client.waitForEvents([
-  'conversation.item.added',
-  'conversation.item.done'
-], 10000);
-
-// Wait for complete response cycle
-const response = await waitForCompleteResponse(client);
-const text = extractTextFromResponse(response.allEvents);
-```
-
-### Sending Events
-
-```typescript
-// Send any client event
-client.sendEvent({
-  type: 'conversation.item.create',
-  item: createTextMessage('Hello'),
-});
-
-// Create different message types
-const userMsg = createTextMessage('Hello', 'user', 'msg-123');
-const functionOutput = createFunctionCallOutput('call-123', '{"result": true}');
-```
-
-### Assertions
-
-```typescript
-// Assert event properties
-assertEvent(event, 'session.created', (evt) => {
-  expect(evt.session.id).toBeDefined();
-  expect(evt.session.model).toBe('expected-model');
-});
-```
-
-### All Helper Functions
-
-- `createWebSocketTestClient()` - Create test client
-- `waitForEvent()` - Wait for specific event
-- `waitForEvents()` - Wait for multiple events
-- `waitForCompleteResponse()` - Wait for full response
-- `assertEvent()` - Assert event properties
-- `createTextMessage()` - Create text message item
-- `createFunctionCallOutput()` - Create function output
-- `extractTextFromResponse()` - Extract text from events
-- `extractAudioTranscriptFromResponse()` - Extract audio transcript
-
-See [`api/README.md`](./api/README.md) for detailed API documentation.
-
----
-
-## Troubleshooting
-
-### Connection Refused
-
-**Problem:** Tests fail with `ECONNREFUSED`  
-**Solution:** Start the server first:
-```bash
-cd src && npm start
-```
-Wait for "Application Server listening on port 4000", then run tests.
-
-### Tests Timeout
-
-**Problem:** Tests timeout waiting for events  
-**Solutions:**
-- Check server logs for errors
-- Verify environment variables are set
-- Increase timeout: `await client.waitForEvent('event', 30000)`
-- Make sure server is running on correct port (4000)
-
-### Port Already in Use
-
-**Problem:** Can't start server - port 4000 in use  
-**Solution:**
-```bash
-# Kill process on port 4000
-lsof -ti:4000 | xargs kill
-
-# Or use different port
-WS_APP_PORT=4001 npm start  # Terminal 1
-WS_APP_PORT=4001 npm test   # Terminal 2
-```
-
-### Module Not Found
-
-**Problem:** `Cannot find module 'uuid'`  
-**Solution:** Run `npm install`
-
-### Debugging Tests
-
-```typescript
-// View all received events
-it('debug test', async () => {
-  const client = await createWebSocketTestClient('test');
-  await client.waitForEvent('session.created');
-  
-  console.log('Events:', JSON.stringify(client.events, null, 2));
-});
-
-// Increase timeout for debugging
-jest.setTimeout(300000); // 5 minutes
-```
-
----
-
-## Why API Tests Only?
-
-We chose **API integration tests** over traditional unit tests.
-
-### What We DON'T Do ❌
-
-```typescript
-// Unit testing internal nodes (we avoid this)
-it('node should process input', () => {
-  const node = new TextInputNode(config);
-  const result = node.process(context, input);
-  expect(result.messages).toContainEqual(...);
-});
-```
-**Problem:** Tests implementation details, breaks on refactoring
-
-### What We DO ✅
-
-```typescript
-// Testing API behavior (our approach)
-it('should create conversation item', async () => {
-  const client = await createWebSocketTestClient('session-123');
-  await client.waitForEvent('session.created');
-  
-  client.sendEvent({
-    type: 'conversation.item.create',
-    item: createTextMessage('Hello'),
-  });
-  
-  const event = await client.waitForEvent('conversation.item.added');
-  expect(event.item.content[0].text).toBe('Hello');
-});
-```
-**Benefit:** Tests actual behavior, survives refactoring
-
-### Benefits
-
-1. **Tests Real Behavior** - Validates what users actually experience
-2. **OpenAI Compliance** - Ensures API contract adherence
-3. **Refactor-Safe** - Tests survive internal code changes
-4. **Living Documentation** - Tests show how to use the API
-5. **Higher Confidence** - Tests complete integration paths
-6. **Fewer Tests** - 18 comprehensive tests vs 100+ unit tests
-
-### Trade-offs
-
-We accept these trade-offs for better overall testing:
-
-- ⚠️ Requires running server (~1 command in separate terminal)
-- ⚠️ Slower execution (~6 seconds vs milliseconds for unit tests)
-- ⚠️ May need environment configuration for API keys
-- ⚠️ Debugging spans multiple components
-
-**Result:** Better testing with less maintenance burden. Simple setup, comprehensive coverage!
-
----
-
-## CI/CD Integration
-
-### GitHub Actions Example
-
-```yaml
-name: API Tests
-
-on: [push, pull_request]
-
-jobs:
-  api-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '18'
-      
-      - name: Install dependencies
-        run: npm install
-        
-      - name: Start server
-        run: cd src && npm start &
-        
-      - name: Wait for server
-        run: sleep 5
-        
-      - name: Run tests
-        run: npm test
-        
-      - name: Upload coverage
-        uses: codecov/codecov-action@v2
-        if: always()
-```
-
----
-
-## Project Structure
-
-```
-__tests__/
-├── api/
-│   ├── realtime-api.spec.ts      # 18 test cases
-│   ├── websocket-test-helper.ts  # Test utilities
-│   ├── websocket-server-helper.ts
-│   └── README.md                 # Detailed API docs
-│
-├── utils/                        # Legacy (kept for reference)
-│   ├── mock-helpers.ts
-│   └── graph-test-helpers.ts
-│
-├── config.ts                     # Test constants
-├── setup.ts                      # Jest setup
-├── test-setup.ts                 # Test environment
-└── README.md                     # This file
-```
-
----
-
-## Test Statistics
-
-- **Test Files:** 1 (`realtime-api.spec.ts`)
-- **Test Cases:** 18 passing, 1 skipped
-- **Test Duration:** ~6 seconds
-- **Test Categories:** 8
-- **Lines of Code:** ~1,100 test code
-
-### Latest Results
-
-```
-PASS __tests__/api/realtime-api.spec.ts (6.704 s)
-  ✓ Session Management (3/3)
-  ✓ Conversation Management (5/5)
-  ✓ Response Generation (4/4)
-  ✓ Function Calling (1/1)
-  ✓ Audio Input Management (1/2, 1 skipped)
-  ✓ Error Handling (2/2)
-  ✓ Multi-Session Support (1/1)
-  ✓ Workspace Isolation (1/1)
-
-Tests: 18 passed, 1 skipped, 19 total
-Time: 6.826 s
-```
-
----
-
-## Configuration
-
-### Jest (`jest.config.js`)
-
-- Timeout: 30 seconds
-- Environment: Node.js
-- Uses: ts-jest with `tsconfig.test.json`
-
-### TypeScript (`tsconfig.test.json`)
-
-- Extends: `src/tsconfig.json`
-- Includes: `__tests__/**/*.ts`
-- CommonJS modules for Jest compatibility
-
-### Environment (`.env.test`)
-
-```bash
-WS_APP_PORT=4000
-INWORLD_API_KEY=your-key
-WORKSPACE_ID=your-workspace
-```
-
----
-
-## Contributing
-
-When adding new features:
-
-1. **Add API tests** for the new behavior
-2. **Test success and error cases**
-3. **Use existing tests as templates**
-4. **Update this README** if patterns change
-5. **Ensure all tests pass** before committing
-
-### Example: Adding a New Test
-
-```typescript
-describe('New Feature', () => {
-  let client: WebSocketTestClient;
-  const sessionKey = `test-session-${uuidv4()}`;
-
-  beforeEach(async () => {
-    client = await createWebSocketTestClient(sessionKey);
-    await client.waitForEvent('session.created');
-  });
-
-  afterEach(async () => {
-    if (client) await client.close();
-  });
-
-  it('should handle new feature', async () => {
-    // Test implementation
-  });
-});
-```
-
----
-
-## Support
-
-- **Detailed API docs:** [`api/README.md`](./api/README.md)
-- **Jest documentation:** https://jestjs.io/
-- **WebSocket API spec:** Check `src/REALTIME_API.md`
-
----
-
-**Last Updated:** November 2024  
-**Status:** ✅ All tests passing  
-**Test Coverage:** Run `npm run test:coverage` to check
diff --git a/realtime-service/__tests__/api/README.md b/realtime-service/__tests__/api/README.md
deleted file mode 100644
index c9a7f86..0000000
--- a/realtime-service/__tests__/api/README.md
+++ /dev/null
@@ -1,312 +0,0 @@
-# API Test Utilities Reference
-
-Helper functions and utilities for writing API integration tests.
-
-> **Main Documentation:** See [`../__tests__/README.md`](../README.md) for complete testing guide.
-
----
-
-## WebSocket Test Client
-
-### Creating a Client
-
-```typescript
-import { createWebSocketTestClient } from './websocket-test-helper';
-
-const client = await createWebSocketTestClient(
-  sessionKey,      // string: unique session identifier
-  port?,           // number: server port (default: 3001)
-  workspaceId?     // string: optional workspace ID
-);
-```
-
-### Client Interface
-
-```typescript
-interface WebSocketTestClient {
-  ws: WebSocket;                    // Raw WebSocket instance
-  events: RT.ServerEvent[];         // All received events
-  
-  // Wait for specific event
-  waitForEvent(eventType: string, timeout?: number): Promise<RT.ServerEvent>;
-  
-  // Wait for multiple events in sequence
-  waitForEvents(eventTypes: string[], timeout?: number): Promise<RT.ServerEvent[]>;
-  
-  // Send client event
-  sendEvent(event: RT.ClientEvent): void;
-  
-  // Close connection
-  close(): Promise<void>;
-}
-```
-
----
-
-## Event Utilities
-
-### Wait for Event
-
-```typescript
-// Wait for single event (default 5s timeout)
-const event = await client.waitForEvent('session.created');
-
-// With custom timeout
-const event = await client.waitForEvent('response.done', 30000);
-```
-
-### Wait for Multiple Events
-
-```typescript
-const [event1, event2] = await client.waitForEvents([
-  'conversation.item.added',
-  'conversation.item.done'
-], 10000);
-```
-
-### Wait for Complete Response
-
-```typescript
-import { waitForCompleteResponse } from './websocket-test-helper';
-
-const response = await waitForCompleteResponse(client, 30000);
-// Returns: { created, done, allEvents }
-```
-
-### Collect Events Until
-
-```typescript
-import { collectEventsUntil } from './websocket-test-helper';
-
-const events = await collectEventsUntil(client, 'response.done', 10000);
-```
-
----
-
-## Message Creation
-
-### Create Text Message
-
-```typescript
-import { createTextMessage } from './websocket-test-helper';
-
-// Basic
-const msg = createTextMessage('Hello, world!');
-
-// With role
-const userMsg = createTextMessage('Hello', 'user');
-const sysMsg = createTextMessage('Instructions', 'system');
-
-// With ID
-const msg = createTextMessage('Hello', 'user', 'msg-123');
-```
-
-Returns:
-```typescript
-{
-  type: 'message',
-  role: 'user' | 'assistant' | 'system',
-  content: [{ type: 'input_text', text: string }],
-  id?: string
-}
-```
-
-### Create Function Call Output
-
-```typescript
-import { createFunctionCallOutput } from './websocket-test-helper';
-
-const output = createFunctionCallOutput(
-  'call-123',                    // call_id
-  '{"temperature": 72}',         // output (JSON string)
-  'output-456'                   // optional id
-);
-```
-
-Returns:
-```typescript
-{
-  type: 'function_call_output',
-  call_id: string,
-  output: string,
-  id?: string
-}
-```
-
----
-
-## Assertions
-
-### Assert Event Properties
-
-```typescript
-import { assertEvent } from './websocket-test-helper';
-
-// Basic assertion
-assertEvent(event, 'session.created');
-
-// With additional checks
-assertEvent(event, 'session.created', (evt) => {
-  expect(evt.session.id).toBeDefined();
-  expect(evt.session.model).toBe('expected-model');
-  expect(evt.session.audio.output.voice).toBe('Dennis');
-});
-```
-
----
-
-## Response Utilities
-
-### Extract Text from Response
-
-```typescript
-import { extractTextFromResponse } from './websocket-test-helper';
-
-const response = await waitForCompleteResponse(client);
-const text = extractTextFromResponse(response.allEvents);
-
-console.log('Response text:', text);
-```
-
-### Extract Audio Transcript
-
-```typescript
-import { extractAudioTranscriptFromResponse } from './websocket-test-helper';
-
-const response = await waitForCompleteResponse(client);
-const transcript = extractAudioTranscriptFromResponse(response.allEvents);
-
-console.log('Audio transcript:', transcript);
-```
-
----
-
-## Complete Example
-
-```typescript
-import { v4 as uuidv4 } from 'uuid';
-import {
-  createWebSocketTestClient,
-  createTextMessage,
-  waitForCompleteResponse,
-  extractTextFromResponse,
-  assertEvent,
-} from './websocket-test-helper';
-
-it('should handle conversation flow', async () => {
-  // Create client
-  const sessionKey = `test-${uuidv4()}`;
-  const client = await createWebSocketTestClient(sessionKey, 4000);
-  
-  try {
-    // Wait for session
-    const sessionEvent = await client.waitForEvent('session.created');
-    assertEvent(sessionEvent, 'session.created', (evt) => {
-      expect(evt.session.id).toBeDefined();
-    });
-    
-    // Create conversation item
-    client.sendEvent({
-      type: 'conversation.item.create',
-      item: createTextMessage('Hello, how are you?', 'user'),
-    });
-    
-    // Verify item was added
-    const [added, done] = await client.waitForEvents([
-      'conversation.item.added',
-      'conversation.item.done'
-    ]);
-    
-    assertEvent(added, 'conversation.item.added');
-    assertEvent(done, 'conversation.item.done');
-    
-    // Generate response
-    client.sendEvent({ type: 'response.create' });
-    
-    // Wait for complete response
-    const response = await waitForCompleteResponse(client, 30000);
-    const text = extractTextFromResponse(response.allEvents);
-    
-    expect(text.length).toBeGreaterThan(0);
-    
-  } finally {
-    await client.close();
-  }
-});
-```
-
----
-
-## Server Management (Optional)
-
-For automated server lifecycle management:
-
-```typescript
-import {
-  startTestServer,
-  stopTestServer,
-  waitForServerReady,
-  getServerPort,
-} from './websocket-server-helper';
-
-// Start server
-const port = await startTestServer(4000);
-await waitForServerReady(port);
-
-// Run tests...
-
-// Stop server
-await stopTestServer();
-```
-
----
-
-## Type Definitions
-
-All types are imported from `../../src/types/realtime`:
-
-```typescript
-import * as RT from '../../src/types/realtime';
-
-// Client events
-RT.ClientEvent
-RT.SessionUpdateEvent
-RT.ConversationItemCreateEvent
-RT.ResponseCreateEvent
-// ... etc
-
-// Server events
-RT.ServerEvent
-RT.SessionCreatedEvent
-RT.ConversationItemAddedEvent
-RT.ResponseCreatedEvent
-// ... etc
-
-// Data types
-RT.MessageItem
-RT.FunctionCallItem
-RT.FunctionCallOutputItem
-RT.Session
-RT.Response
-```
-
----
-
-## Helper Function Summary
-
-| Function | Purpose |
-|----------|---------|
-| `createWebSocketTestClient()` | Create and connect test client |
-| `waitForEvent()` | Wait for specific event |
-| `waitForEvents()` | Wait for multiple events |
-| `waitForCompleteResponse()` | Wait for full response cycle |
-| `collectEventsUntil()` | Collect all events until target |
-| `assertEvent()` | Assert event type and properties |
-| `createTextMessage()` | Create text message item |
-| `createFunctionCallOutput()` | Create function output item |
-| `extractTextFromResponse()` | Extract text from response events |
-| `extractAudioTranscriptFromResponse()` | Extract audio transcript |
-
----
-
-For complete testing documentation, examples, and troubleshooting, see the [main README](../README.md).
diff --git a/realtime-service/__tests__/api/realtime-api.spec.ts b/realtime-service/__tests__/api/realtime-api.spec.ts
deleted file mode 100644
index 85b8690..0000000
--- a/realtime-service/__tests__/api/realtime-api.spec.ts
+++ /dev/null
@@ -1,885 +0,0 @@
-/**
- * OpenAI Realtime API Integration Tests
- * Tests the WebSocket API behavior end-to-end
- * 
- * IMPORTANT: Before running these tests, start the WebSocket server:
- *   1. Open a new terminal
- *   2. cd to the serving/realtime-service/src directory
- *   3. npm start
- *   4. Wait for "Application Server listening on port 3001"
- *   5. Then run: npm run test:api
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import * as RT from '../../src/types/realtime';
-import {
-  createWebSocketTestClient,
-  assertEvent,
-  createTextMessage,
-  createFunctionCallOutput,
-  waitForCompleteResponse,
-  extractTextFromResponse,
-  verifyContinuationAfterCancellation,
-  WebSocketTestClient,
-} from './websocket-test-helper';
-
-// Get port from environment variable
-const TEST_PORT = process.env.WS_APP_PORT ? parseInt(process.env.WS_APP_PORT) : 4000;
-
-describe('OpenAI Realtime API - Integration Tests', () => {
-  jest.setTimeout(60000); // 60 second timeout for API tests
-
-  describe('Session Management', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should create a session on connection and send session.created event', async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-
-      const sessionCreatedEvent = await client.waitForEvent('session.created', 5000);
-
-      assertEvent(sessionCreatedEvent, 'session.created', (event: RT.SessionCreatedEvent) => {
-        expect(event.session).toBeDefined();
-        expect(event.session.id).toBeDefined();
-        expect(event.session.type).toBe('realtime');
-        expect(event.session.object).toBe('realtime.session');
-        expect(event.session.model).toBeDefined();
-        expect(event.session.output_modalities).toEqual(expect.arrayContaining(['audio', 'text']));
-        expect(event.session.audio).toBeDefined();
-        expect(event.session.audio.input).toBeDefined();
-        expect(event.session.audio.output).toBeDefined();
-        expect(event.session.audio.output.voice).toBeDefined();
-        expect(event.session.instructions).toBeDefined();
-      });
-    });
-
-    it('should update session configuration via session.update', async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-
-      await client.waitForEvent('session.created');
-
-      const newInstructions = 'You are a helpful assistant that speaks like a pirate.';
-      const newVoice = 'TestVoice';
-
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          instructions: newInstructions,
-          audio: {
-            output: {
-              voice: newVoice,
-            },
-          },
-          temperature: 0.9,
-        },
-      });
-
-      const sessionUpdatedEvent = await client.waitForEvent('session.updated', 5000);
-
-      assertEvent(sessionUpdatedEvent, 'session.updated', (event: RT.SessionUpdatedEvent) => {
-        expect(event.session.instructions).toBe(newInstructions);
-        expect(event.session.audio.output.voice).toBe(newVoice);
-        expect(event.session.temperature).toBe(0.9);
-      });
-    });
-
-    it('should update turn detection settings', async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-
-      await client.waitForEvent('session.created');
-
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          audio: {
-            input: {
-              turn_detection: {
-                type: 'semantic_vad',
-                eagerness: 'high',
-                create_response: true,
-                interrupt_response: true,
-              },
-            },
-          },
-        },
-      });
-
-      const sessionUpdatedEvent = await client.waitForEvent('session.updated', 5000);
-
-      assertEvent(sessionUpdatedEvent, 'session.updated', (event: RT.SessionUpdatedEvent) => {
-        expect(event.session.audio.input.turn_detection).toBeDefined();
-        expect(event.session.audio.input.turn_detection?.type).toBe('semantic_vad');
-        if (event.session.audio.input.turn_detection?.type === 'semantic_vad') {
-          expect(event.session.audio.input.turn_detection.eagerness).toBe('high');
-        }
-      });
-    });
-  });
-
-  describe('Conversation Management', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    beforeEach(async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-      await client.waitForEvent('session.created');
-    });
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should create a conversation item and receive confirmation events', async () => {
-      const messageId = `msg-${uuidv4()}`;
-      const messageText = 'Hello, this is a test message.';
-
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage(messageText, 'user', messageId),
-      });
-
-      const events = await client.waitForEvents([
-        'conversation.item.added',
-        'conversation.item.done',
-      ], 5000);
-
-      const [addedEvent, doneEvent] = events;
-
-      assertEvent(addedEvent, 'conversation.item.added', (event: RT.ConversationItemAddedEvent) => {
-        expect(event.item.id).toBe(messageId);
-        expect(event.item.type).toBe('message');
-        expect(event.item.status).toBe('completed');
-      });
-
-      assertEvent(doneEvent, 'conversation.item.done', (event: RT.ConversationItemDoneEvent) => {
-        expect(event.item.id).toBe(messageId);
-      });
-    });
-
-    it('should retrieve a conversation item by ID', async () => {
-      const messageId = `msg-${uuidv4()}`;
-      const messageText = 'Test message for retrieval';
-
-      // Create item first
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage(messageText, 'user', messageId),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Retrieve the item
-      client.sendEvent({
-        type: 'conversation.item.retrieve',
-        item_id: messageId,
-      });
-
-      const retrievedEvent = await client.waitForEvent('conversation.item.retrieved', 5000);
-
-      assertEvent(retrievedEvent, 'conversation.item.retrieved', (event: RT.ConversationItemRetrievedEvent) => {
-        expect(event.item.id).toBe(messageId);
-        expect(event.item.type).toBe('message');
-      });
-    });
-
-    it('should delete a conversation item', async () => {
-      const messageId = `msg-${uuidv4()}`;
-
-      // Create item first
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Message to delete', 'user', messageId),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Delete the item
-      client.sendEvent({
-        type: 'conversation.item.delete',
-        item_id: messageId,
-      });
-
-      const deletedEvent = await client.waitForEvent('conversation.item.deleted', 5000);
-
-      assertEvent(deletedEvent, 'conversation.item.deleted', (event: RT.ConversationItemDeletedEvent) => {
-        expect(event.item_id).toBe(messageId);
-      });
-
-      // Verify item is gone by trying to retrieve it
-      client.sendEvent({
-        type: 'conversation.item.retrieve',
-        item_id: messageId,
-      });
-
-      const errorEvent = await client.waitForEvent('error', 5000);
-
-      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
-        expect(event.error.code).toBe('item_not_found');
-      });
-    });
-
-    it('should handle truncation of conversation items', async () => {
-      const messageId = `msg-${uuidv4()}`;
-
-      // Create an assistant message with audio (in real scenario)
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: {
-          type: 'message',
-          role: 'assistant',
-          id: messageId,
-          content: [
-            {
-              type: 'audio',
-              audio: 'base64audiodata',
-              transcript: 'This is a long message that will be truncated',
-            },
-          ],
-        } as RT.MessageItem,
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Truncate at 1000ms
-      client.sendEvent({
-        type: 'conversation.item.truncate',
-        item_id: messageId,
-        content_index: 0,
-        audio_end_ms: 1000,
-      });
-
-      const truncatedEvent = await client.waitForEvent('conversation.item.truncated', 5000);
-
-      assertEvent(truncatedEvent, 'conversation.item.truncated', (event: RT.ConversationItemTruncatedEvent) => {
-        expect(event.item_id).toBe(messageId);
-        expect(event.content_index).toBe(0);
-        expect(event.audio_end_ms).toBe(1000);
-      });
-    });
-
-    it('should return error when trying to retrieve non-existent item', async () => {
-      const nonExistentId = `msg-${uuidv4()}`;
-
-      client.sendEvent({
-        type: 'conversation.item.retrieve',
-        item_id: nonExistentId,
-      });
-
-      const errorEvent = await client.waitForEvent('error', 5000);
-
-      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
-        expect(event.error.type).toBe('invalid_request_error');
-        expect(event.error.code).toBe('item_not_found');
-        expect(event.error.message).toContain(nonExistentId);
-      });
-    });
-  });
-
-  describe('Response Generation', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    beforeEach(async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-      await client.waitForEvent('session.created');
-
-      // Set up session with text-only output for simpler testing
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          output_modalities: ['text'],
-          instructions: 'You are a helpful assistant. Keep responses brief.',
-        },
-      });
-
-      await client.waitForEvent('session.updated');
-    });
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should generate a response to a user message', async () => {
-      // Create user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Say hello', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      const response = await waitForCompleteResponse(client, 30000);
-
-      assertEvent(response.created, 'response.created', (event: RT.ResponseCreatedEvent) => {
-        expect(event.response.id).toBeDefined();
-        expect(event.response.status).toBe('in_progress');
-      });
-
-      assertEvent(response.done, 'response.done', (event: RT.ResponseDoneEvent) => {
-        expect(event.response.id).toBe(response.created.response.id);
-        expect(['completed', 'incomplete']).toContain(event.response.status);
-      });
-
-      // Verify we got text output
-      const text = extractTextFromResponse(response.allEvents);
-      expect(text.length).toBeGreaterThan(0);
-    });
-
-    it('should emit response events in correct order', async () => {
-      // Create user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Count to three', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      const response = await waitForCompleteResponse(client, 30000);
-
-      const eventTypes = response.allEvents.map(e => e.type);
-
-      // Verify event ordering
-      const createdIndex = eventTypes.indexOf('response.created');
-      const doneIndex = eventTypes.indexOf('response.done');
-
-      expect(createdIndex).toBeGreaterThanOrEqual(0);
-      expect(doneIndex).toBeGreaterThan(createdIndex);
-
-      // All response-related events should be between created and done
-      const betweenEvents = eventTypes.slice(createdIndex + 1, doneIndex);
-      betweenEvents.forEach(type => {
-        expect(type).toMatch(/^(response\.|conversation\.item)/);
-      });
-    });
-
-    it('should cancel response immediately after creation', async () => {
-      // Create user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Tell me a long story', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      // Wait for response to start
-      const createdEvent = await client.waitForEvent('response.created', 5000);
-      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
-
-      // Cancel immediately after creation
-      client.sendEvent({
-        type: 'response.cancel',
-        response_id: responseId,
-      });
-
-      // Wait for response.done with cancelled status
-      const doneEvent = await client.waitForEvent('response.done', 10000);
-
-      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
-        expect(event.response.id).toBe(responseId);
-        expect(event.response.status).toBe('cancelled');
-        expect(event.response.status_details?.type).toBe('cancelled');
-        expect(event.response.status_details?.reason).toBe('client_cancelled');
-      });
-
-      // Verify conversation continues to work after cancellation
-      await verifyContinuationAfterCancellation(client, responseId, 'Say hello');
-    });
-
-    it('should cancel response after first text delta', async () => {
-      // Create user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Tell me a story', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response (text-only mode already set in session)
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      // Wait for response to start
-      const createdEvent = await client.waitForEvent('response.created', 5000);
-      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
-
-      // Wait for first text delta (using correct event type: response.output_text.delta)
-      const firstDelta = await client.waitForEvent('response.output_text.delta', 10000);
-      expect(firstDelta).toBeDefined();
-
-      // Cancel after receiving first delta
-      client.sendEvent({
-        type: 'response.cancel',
-        response_id: responseId,
-      });
-
-      // Wait for response.done with cancelled status
-      const doneEvent = await client.waitForEvent('response.done', 10000);
-
-      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
-        expect(event.response.id).toBe(responseId);
-        expect(event.response.status).toBe('cancelled');
-        expect(event.response.status_details?.type).toBe('cancelled');
-        expect(event.response.status_details?.reason).toBe('client_cancelled');
-        // Response should have at least one output item with some content
-        expect(event.response.output.length).toBeGreaterThan(0);
-      });
-
-      // Verify conversation continues to work after cancellation
-      await verifyContinuationAfterCancellation(client, responseId, 'Say goodbye');
-    });
-
-    it('should cancel response during audio streaming', async () => {
-      // Update session to enable audio output
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          output_modalities: ['audio', 'text'],
-          instructions: 'You are a helpful assistant. Provide detailed responses.',
-        },
-      });
-
-      await client.waitForEvent('session.updated');
-
-      // Create user message with a prompt that will generate a longer response
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Hello', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response with audio output
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      // Wait for response to start
-      const createdEvent = await client.waitForEvent('response.created', 5000);
-      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
-
-      // Wait for audio to start streaming (using correct event type: response.output_audio.delta)
-      await client.waitForEvent('response.output_audio.delta', 10000);
-
-      // Cancel during audio streaming
-      client.sendEvent({
-        type: 'response.cancel',
-        response_id: responseId,
-      });
-
-      // Wait for response.done with cancelled status
-      const doneEvent = await client.waitForEvent('response.done', 10000);
-
-      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
-        expect(event.response.id).toBe(responseId);
-        expect(event.response.status).toBe('cancelled');
-        expect(event.response.status_details?.type).toBe('cancelled');
-        expect(event.response.status_details?.reason).toBe('client_cancelled');
-      });
-
-      // Verify conversation continues to work after cancellation
-      await verifyContinuationAfterCancellation(client, responseId, 'Hi again');
-    });
-
-    it.skip('should cancel response during long audio/text streaming', async () => {
-      // Update session to enable audio output
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          output_modalities: ['audio', 'text'],
-          instructions: 'You are a helpful assistant. Provide detailed responses.',
-        },
-      });
-
-      await client.waitForEvent('session.updated');
-
-      // Create user message with a prompt that will generate a longer response
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Tell me a detailed story about space exploration with multiple paragraphs', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response with audio output
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      // Wait for response to start
-      const createdEvent = await client.waitForEvent('response.created', 5000);
-      const responseId = (createdEvent as RT.ResponseCreatedEvent).response.id;
-
-      // Wait for audio to start streaming (using correct event type: response.output_audio.delta)
-      await client.waitForEvent('response.output_audio.delta', 10000);
-
-      // Wait just a moment to ensure we're mid-stream (but not so long that response completes)
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      // Cancel during audio streaming
-      client.sendEvent({
-        type: 'response.cancel',
-        response_id: responseId,
-      });
-
-      // Wait for response.done with cancelled status
-      const doneEvent = await client.waitForEvent('response.done', 10000);
-
-      assertEvent(doneEvent, 'response.done', (event: RT.ResponseDoneEvent) => {
-        expect(event.response.id).toBe(responseId);
-        expect(event.response.status).toBe('cancelled');
-        expect(event.response.status_details?.type).toBe('cancelled');
-        expect(event.response.status_details?.reason).toBe('client_cancelled');
-      });
-
-      // Verify conversation continues to work after cancellation
-      await verifyContinuationAfterCancellation(client, responseId, 'What is 2+2?');
-    });
-
-    it('should include usage information in response', async () => {
-      // Create user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('Hello', 'user'),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Request response
-      client.sendEvent({
-        type: 'response.create',
-      });
-
-      const response = await waitForCompleteResponse(client, 30000);
-
-      assertEvent(response.done, 'response.done', (event: RT.ResponseDoneEvent) => {
-        // Usage might be present (depending on implementation)
-        if (event.response.usage) {
-          expect(event.response.usage.total_tokens).toBeGreaterThan(0);
-          expect(event.response.usage.input_tokens).toBeGreaterThanOrEqual(0);
-          expect(event.response.usage.output_tokens).toBeGreaterThan(0);
-        }
-      });
-    });
-  });
-
-  describe('Function Calling', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    beforeEach(async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-      await client.waitForEvent('session.created');
-
-      // Configure session with function tools
-      client.sendEvent({
-        type: 'session.update',
-        session: {
-          output_modalities: ['text'],
-          instructions: 'You are a helpful assistant with access to tools.',
-          tools: [
-            {
-              type: 'function',
-              name: 'get_weather',
-              description: 'Get the current weather for a location',
-              parameters: {
-                type: 'object',
-                properties: {
-                  location: {
-                    type: 'string',
-                    description: 'The city and state, e.g. San Francisco, CA',
-                  },
-                },
-                required: ['location'],
-              },
-            },
-          ],
-          tool_choice: 'auto',
-        },
-      });
-
-      await client.waitForEvent('session.updated');
-    });
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should handle function call output', async () => {
-      const callId = `call-${uuidv4()}`;
-      const functionOutput = JSON.stringify({
-        temperature: 72,
-        condition: 'sunny',
-      });
-
-      // Create function output item
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createFunctionCallOutput(callId, functionOutput),
-      });
-
-      const events = await client.waitForEvents([
-        'conversation.item.added',
-        'conversation.item.done',
-      ], 5000);
-
-      assertEvent(events[0], 'conversation.item.added', (event: RT.ConversationItemAddedEvent) => {
-        expect(event.item.type).toBe('function_call_output');
-        const item = event.item as RT.FunctionCallOutputItem;
-        expect(item.call_id).toBe(callId);
-        expect(item.output).toBe(functionOutput);
-      });
-    });
-  });
-
-  describe('Audio Input Management', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    beforeEach(async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-      await client.waitForEvent('session.created');
-    });
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should handle input audio buffer clear', async () => {
-      // Append some audio data first
-      client.sendEvent({
-        type: 'input_audio_buffer.append',
-        audio: 'YmFzZTY0ZW5jb2RlZGF1ZGlv', // base64 encoded dummy data
-      });
-
-      // Give it a moment to process
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      // Clear the buffer
-      client.sendEvent({
-        type: 'input_audio_buffer.clear',
-      });
-
-      const clearedEvent = await client.waitForEvent('input_audio_buffer.cleared', 5000);
-
-      assertEvent(clearedEvent, 'input_audio_buffer.cleared');
-    });
-
-    // TODO: This test times out - audio buffer commit may require actual audio data or STT setup
-    it.skip('should handle input audio buffer commit', async () => {
-      // NOTE: This test is currently skipped because it requires:
-      // - Proper audio data (not just base64 dummy data)
-      // - Speech-to-text service to be properly configured
-      // - AssemblyAI or other STT provider setup
-
-      // Append audio data
-      client.sendEvent({
-        type: 'input_audio_buffer.append',
-        audio: 'YmFzZTY0ZW5jb2RlZGF1ZGlv',
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      // Commit the buffer
-      client.sendEvent({
-        type: 'input_audio_buffer.commit',
-      });
-
-      const committedEvent = await client.waitForEvent('input_audio_buffer.committed', 30000);
-
-      assertEvent(committedEvent, 'input_audio_buffer.committed', (event: RT.InputAudioBufferCommittedEvent) => {
-        expect(event.item_id).toBeDefined();
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    let client: WebSocketTestClient;
-    const sessionKey = `test-session-${uuidv4()}`;
-
-    beforeEach(async () => {
-      client = await createWebSocketTestClient(sessionKey, TEST_PORT);
-      await client.waitForEvent('session.created');
-    });
-
-    afterEach(async () => {
-      if (client) {
-        await client.close();
-      }
-    });
-
-    it('should return error for invalid event format', async () => {
-      // Send malformed JSON
-      client.ws.send('{ invalid json }');
-
-      const errorEvent = await client.waitForEvent('error', 5000);
-
-      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
-        expect(event.error.type).toBe('invalid_request_error');
-      });
-    });
-
-    it('should return error when truncating user message', async () => {
-      const messageId = `msg-${uuidv4()}`;
-
-      // Create a user message
-      client.sendEvent({
-        type: 'conversation.item.create',
-        item: createTextMessage('User message', 'user', messageId),
-      });
-
-      await client.waitForEvent('conversation.item.done');
-
-      // Try to truncate (only assistant messages can be truncated)
-      client.sendEvent({
-        type: 'conversation.item.truncate',
-        item_id: messageId,
-        content_index: 0,
-        audio_end_ms: 1000,
-      });
-
-      const errorEvent = await client.waitForEvent('error', 5000);
-
-      assertEvent(errorEvent, 'error', (event: RT.ErrorEvent) => {
-        expect(event.error.type).toBe('invalid_request_error');
-        expect(event.error.code).toBe('invalid_item_type');
-      });
-    });
-  });
-
-  describe('Multi-Session Support', () => {
-    it('should handle multiple concurrent sessions', async () => {
-      const session1Key = `test-session-${uuidv4()}`;
-      const session2Key = `test-session-${uuidv4()}`;
-
-      const client1 = await createWebSocketTestClient(session1Key, TEST_PORT);
-      const client2 = await createWebSocketTestClient(session2Key, TEST_PORT);
-
-      try {
-        // Wait for both sessions to be created
-        const [session1Created, session2Created] = await Promise.all([
-          client1.waitForEvent('session.created'),
-          client2.waitForEvent('session.created'),
-        ]);
-
-        // Verify they have different session IDs
-        const s1 = session1Created as RT.SessionCreatedEvent;
-        const s2 = session2Created as RT.SessionCreatedEvent;
-        expect(s1.session.id).not.toBe(s2.session.id);
-
-        // Configure sessions differently
-        client1.sendEvent({
-          type: 'session.update',
-          session: {
-            instructions: 'You are session 1',
-            temperature: 0.5,
-          },
-        });
-
-        client2.sendEvent({
-          type: 'session.update',
-          session: {
-            instructions: 'You are session 2',
-            temperature: 0.9,
-          },
-        });
-
-        const [updated1, updated2] = await Promise.all([
-          client1.waitForEvent('session.updated'),
-          client2.waitForEvent('session.updated'),
-        ]);
-
-        // Verify each session kept its own configuration
-        const u1 = updated1 as RT.SessionUpdatedEvent;
-        const u2 = updated2 as RT.SessionUpdatedEvent;
-        expect(u1.session.instructions).toBe('You are session 1');
-        expect(u1.session.temperature).toBe(0.5);
-        expect(u2.session.instructions).toBe('You are session 2');
-        expect(u2.session.temperature).toBe(0.9);
-      } finally {
-        await client1.close();
-        await client2.close();
-      }
-    });
-  });
-
-  describe('Workspace Isolation', () => {
-    it('should isolate sessions by workspace', async () => {
-      const sessionKey = `test-session-${uuidv4()}`;
-      const workspace1 = `workspace-${uuidv4()}`;
-      const workspace2 = `workspace-${uuidv4()}`;
-
-      const client1 = await createWebSocketTestClient(sessionKey, TEST_PORT, workspace1);
-      const client2 = await createWebSocketTestClient(sessionKey, TEST_PORT, workspace2);
-
-      try {
-        // Both sessions should be created successfully with same key but different workspaces
-        await Promise.all([
-          client1.waitForEvent('session.created'),
-          client2.waitForEvent('session.created'),
-        ]);
-
-        // They should operate independently
-        client1.sendEvent({
-          type: 'session.update',
-          session: {
-            instructions: 'Workspace 1 instructions',
-          },
-        });
-
-        const updated1 = await client1.waitForEvent('session.updated');
-
-        // Verify workspace 1 has its instructions
-        const u1 = updated1 as RT.SessionUpdatedEvent;
-        expect(u1.session.instructions).toBe('Workspace 1 instructions');
-
-        // Workspace 2 should still have default instructions
-        // (we'll verify by updating workspace 2 and checking it didn't get workspace 1's instructions)
-        client2.sendEvent({
-          type: 'session.update',
-          session: {
-            instructions: 'Workspace 2 instructions',
-          },
-        });
-
-        const updated2 = await client2.waitForEvent('session.updated');
-        const u2 = updated2 as RT.SessionUpdatedEvent;
-        expect(u2.session.instructions).toBe('Workspace 2 instructions');
-        expect(u2.session.instructions).not.toBe(u1.session.instructions);
-      } finally {
-        await client1.close();
-        await client2.close();
-      }
-    });
-  });
-});
-
diff --git a/realtime-service/__tests__/api/websocket-server-helper.ts b/realtime-service/__tests__/api/websocket-server-helper.ts
deleted file mode 100644
index c1daa62..0000000
--- a/realtime-service/__tests__/api/websocket-server-helper.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-/**
- * WebSocket Server Helper
- * Manages the WebSocket server lifecycle for integration tests
- */
-
-import { ChildProcess, spawn } from 'child_process';
-import WebSocket from 'ws';
-
-let serverProcess: ChildProcess | null = null;
-let serverPort: number = 3001;
-
-/**
- * Start the WebSocket server for testing
- */
-export async function startTestServer(port: number = 3001): Promise<number> {
-  if (serverProcess) {
-    return serverPort;
-  }
-
-  serverPort = port;
-
-  return new Promise((resolve, reject) => {
-    // Start the server process from the src directory
-    const srcDir = __dirname + '/../../src';
-    serverProcess = spawn('npm', ['start'], {
-      cwd: srcDir,
-      env: {
-        ...process.env,
-        WS_APP_PORT: String(port),
-        AUTH_TOKEN: '', // Disable auth for tests
-        NODE_ENV: 'test',
-      },
-      stdio: 'ignore', // Ignore stdio to prevent blocking
-      detached: true, // Detach so it doesn't block Jest
-    });
-    
-    // Unref so the parent process can exit without waiting
-    serverProcess.unref();
-
-    // Wait for server to be ready by attempting to connect
-    const startTime = Date.now();
-    const maxWait = 15000; // 15 seconds
-    
-    const checkServer = async (): Promise<void> => {
-      while (Date.now() - startTime < maxWait) {
-        try {
-          await waitForServerReady(port, 1);
-          resolve(port);
-          return;
-        } catch (error) {
-          // Server not ready yet, wait a bit
-          await new Promise(r => setTimeout(r, 500));
-        }
-      }
-      reject(new Error('Server startup timeout'));
-    };
-    
-    checkServer().catch(reject);
-  });
-}
-
-/**
- * Stop the WebSocket server
- */
-export async function stopTestServer(): Promise<void> {
-  if (!serverProcess) {
-    return;
-  }
-
-  return new Promise((resolve) => {
-    const process = serverProcess!;
-    serverProcess = null;
-
-    process.on('exit', () => {
-      resolve();
-    });
-
-    process.kill('SIGTERM');
-
-    // Force kill after 5 seconds
-    setTimeout(() => {
-      if (!process.killed) {
-        process.kill('SIGKILL');
-        resolve();
-      }
-    }, 5000);
-  });
-}
-
-/**
- * Wait for server to be ready by attempting to connect
- */
-export async function waitForServerReady(port: number, maxAttempts: number = 20): Promise<void> {
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const ws = new WebSocket(`ws://localhost:${port}/session?key=test-health-check`);
-        
-        const timeout = setTimeout(() => {
-          ws.close();
-          reject(new Error('Connection timeout'));
-        }, 1000);
-
-        ws.on('open', () => {
-          clearTimeout(timeout);
-          ws.close();
-          resolve();
-        });
-
-        ws.on('error', () => {
-          clearTimeout(timeout);
-          reject(new Error('Connection failed'));
-        });
-      });
-
-      // Server is ready
-      return;
-    } catch (error) {
-      // Wait before retrying
-      await new Promise(resolve => setTimeout(resolve, 500));
-    }
-  }
-
-  throw new Error('Server failed to become ready');
-}
-
-/**
- * Get the current server port
- */
-export function getServerPort(): number {
-  return serverPort;
-}
-
diff --git a/realtime-service/__tests__/api/websocket-test-helper.ts b/realtime-service/__tests__/api/websocket-test-helper.ts
deleted file mode 100644
index ce7b207..0000000
--- a/realtime-service/__tests__/api/websocket-test-helper.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-/**
- * WebSocket API Test Helper
- * Provides utilities for testing the WebSocket Realtime API
- */
-
-import WebSocket from 'ws';
-import * as RT from '../../src/types/realtime';
-
-export interface WebSocketTestClient {
-  ws: WebSocket;
-  events: RT.ServerEvent[];
-  waitForEvent: (eventType: string, timeout?: number) => Promise<RT.ServerEvent>;
-  waitForEvents: (eventTypes: string[], timeout?: number) => Promise<RT.ServerEvent[]>;
-  sendEvent: (event: RT.ClientEvent) => void;
-  clearEvents: () => void;
-  close: () => Promise<void>;
-}
-
-/**
- * Create a WebSocket test client that connects to the realtime service
- */
-export async function createWebSocketTestClient(
-  sessionKey: string,
-  port: number = 3001,
-  workspaceId?: string
-): Promise<WebSocketTestClient> {
-  const options: any = {};
-  if (workspaceId) {
-    options.headers = {
-      'workspace-id': workspaceId,
-    };
-  }
-
-  const ws = new WebSocket(`ws://localhost:${port}/session?key=${sessionKey}`, options);
-
-  const events: RT.ServerEvent[] = [];
-  const eventPromises = new Map<string, Array<(event: RT.ServerEvent) => void>>();
-
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      ws.close();
-      reject(new Error(
-        `WebSocket connection timeout. ` +
-        `Make sure the server is running: cd src && npm start`
-      ));
-    }, 5000);
-
-    ws.on('open', () => {
-      clearTimeout(timeout);
-
-      const client: WebSocketTestClient = {
-        ws,
-        events,
-
-        waitForEvent: (eventType: string, timeout = 5000): Promise<RT.ServerEvent> => {
-          // Check if event already received
-          const existingEvent = events.find(e => e.type === eventType);
-          if (existingEvent) {
-            return Promise.resolve(existingEvent);
-          }
-
-          // Wait for new event
-          return new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => {
-              reject(new Error(`Timeout waiting for event: ${eventType}`));
-            }, timeout);
-
-            if (!eventPromises.has(eventType)) {
-              eventPromises.set(eventType, []);
-            }
-
-            eventPromises.get(eventType)!.push((event) => {
-              clearTimeout(timeoutId);
-              resolve(event);
-            });
-          });
-        },
-
-        waitForEvents: async (eventTypes: string[], timeout = 5000): Promise<RT.ServerEvent[]> => {
-          const results: RT.ServerEvent[] = [];
-          const startTime = Date.now();
-
-          for (const eventType of eventTypes) {
-            const remainingTime = timeout - (Date.now() - startTime);
-            if (remainingTime <= 0) {
-              throw new Error(`Timeout waiting for events: ${eventTypes.join(', ')}`);
-            }
-
-            const event = await client.waitForEvent(eventType, remainingTime);
-            results.push(event);
-          }
-
-          return results;
-        },
-
-        sendEvent: (event: RT.ClientEvent): void => {
-          ws.send(JSON.stringify(event));
-        },
-
-        clearEvents: (): void => {
-          events.length = 0;
-        },
-
-        close: (): Promise<void> => {
-          return new Promise((resolve) => {
-            ws.once('close', () => resolve());
-            ws.close();
-          });
-        },
-      };
-
-      resolve(client);
-    });
-
-    ws.on('message', (data: any) => {
-      try {
-        const event = JSON.parse(data.toString()) as RT.ServerEvent;
-        events.push(event);
-
-        // Resolve any waiting promises for this event type
-        const waiters = eventPromises.get(event.type);
-        if (waiters && waiters.length > 0) {
-          const waiter = waiters.shift()!;
-          waiter(event);
-        }
-      } catch (error) {
-        console.error('Failed to parse WebSocket message:', error);
-      }
-    });
-
-    ws.on('error', (error) => {
-      clearTimeout(timeout);
-      reject(new Error(
-        `WebSocket connection failed: ${error.message}\n` +
-        `\n` +
-        `Make sure the server is running on port ${port}:\n` +
-        `  1. Open a new terminal\n` +
-        `  2. cd <path-to-project>/serving/realtime-service/src\n` +
-        `  3. npm start\n` +
-        `  4. Wait for "Application Server listening on port ${port}"\n` +
-        `  5. Then run: npm run test:api`
-      ));
-    });
-  });
-}
-
-/**
- * Helper to collect all events until a specific event type is received
- */
-export async function collectEventsUntil(
-  client: WebSocketTestClient,
-  untilEventType: string,
-  timeout: number = 5000
-): Promise<RT.ServerEvent[]> {
-  const startLength = client.events.length;
-  await client.waitForEvent(untilEventType, timeout);
-  return client.events.slice(startLength);
-}
-
-/**
- * Assert that an event matches expected properties
- */
-export function assertEvent(
-  event: RT.ServerEvent,
-  expectedType: string,
-  additionalChecks?: (event: any) => void
-): void {
-  expect(event.type).toBe(expectedType);
-  expect(event.event_id).toBeDefined();
-  
-  if (additionalChecks) {
-    additionalChecks(event);
-  }
-}
-
-/**
- * Create a text message conversation item
- */
-export function createTextMessage(
-  text: string,
-  role: 'user' | 'assistant' | 'system' = 'user',
-  id?: string
-): RT.MessageItem {
-  return {
-    type: 'message',
-    role,
-    content: [
-      {
-        type: 'input_text',
-        text,
-      },
-    ],
-    ...(id && { id }),
-  };
-}
-
-/**
- * Create a function call output item
- */
-export function createFunctionCallOutput(
-  callId: string,
-  output: string,
-  id?: string
-): RT.FunctionCallOutputItem {
-  return {
-    type: 'function_call_output',
-    call_id: callId,
-    output,
-    ...(id && { id }),
-  };
-}
-
-/**
- * Wait for a complete response (from response.created to response.done)
- */
-export async function waitForCompleteResponse(
-  client: WebSocketTestClient,
-  timeout: number = 30000
-): Promise<{
-  created: RT.ResponseCreatedEvent;
-  done: RT.ResponseDoneEvent;
-  allEvents: RT.ServerEvent[];
-}> {
-  const startLength = client.events.length;
-  
-  const created = await client.waitForEvent('response.created', timeout);
-  const done = await client.waitForEvent('response.done', timeout);
-  
-  const allEvents = client.events.slice(startLength);
-  
-  return {
-    created: created as RT.ResponseCreatedEvent,
-    done: done as RT.ResponseDoneEvent,
-    allEvents,
-  };
-}
-
-/**
- * Extract text content from a response
- */
-export function extractTextFromResponse(events: RT.ServerEvent[]): string {
-  let text = '';
-  
-  for (const event of events) {
-    if (event.type === 'response.output_text.delta') {
-      const deltaEvent = event as RT.ResponseTextDeltaEvent;
-      text += deltaEvent.delta;
-    }
-  }
-  
-  return text;
-}
-
-/**
- * Extract audio transcript from a response
- */
-export function extractAudioTranscriptFromResponse(events: RT.ServerEvent[]): string {
-  let transcript = '';
-  
-  for (const event of events) {
-    if (event.type === 'response.output_audio_transcript.delta') {
-      const deltaEvent = event as RT.ResponseAudioTranscriptDeltaEvent;
-      transcript += deltaEvent.delta;
-    }
-  }
-  
-  return transcript;
-}
-
-/**
- * Verify that a new conversation request works after cancellation
- */
-export async function verifyContinuationAfterCancellation(
-  client: WebSocketTestClient,
-  originalResponseId: string,
-  newMessageText: string,
-): Promise<void> {
-  // Clear events to ensure we wait for NEW response events
-  client.clearEvents();
-
-  // Verify we can send a new conversation request after cancellation
-  client.sendEvent({
-    type: 'conversation.item.create',
-    item: createTextMessage(newMessageText, 'user'),
-  });
-
-  await client.waitForEvent('conversation.item.done');
-
-  client.sendEvent({
-    type: 'response.create',
-  });
-
-  const newResponse = await waitForCompleteResponse(client, 30000);
-
-  assertEvent(newResponse.created, 'response.created', (event: RT.ResponseCreatedEvent) => {
-    expect(event.response.id).toBeDefined();
-    expect(event.response.id).not.toBe(originalResponseId);
-    expect(event.response.status).toBe('in_progress');
-  });
-
-  assertEvent(newResponse.done, 'response.done', (event: RT.ResponseDoneEvent) => {
-    expect(['completed', 'incomplete']).toContain(event.response.status);
-  });
-
-  // Verify we got some output in the new response
-  const hasOutput = newResponse.allEvents.some(
-    e => e.type === 'response.output_text.delta' || e.type === 'response.output_audio.delta'
-  );
-  expect(hasOutput).toBe(true);
-}
-
diff --git a/realtime-service/__tests__/config.ts b/realtime-service/__tests__/config.ts
deleted file mode 100644
index 47f9d44..0000000
--- a/realtime-service/__tests__/config.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * Test configuration constants
- */
-
-export const TEST_SESSION_ID = 'test-session-123';
-export const TEST_INTERACTION_ID = 'test-interaction-456';
-export const TEST_WORKSPACE_ID = 'test-workspace-789';
-
diff --git a/realtime-service/__tests__/setup.ts b/realtime-service/__tests__/setup.ts
deleted file mode 100644
index acc86f6..0000000
--- a/realtime-service/__tests__/setup.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * Jest setup file
- * This file runs before all tests and sets up the testing environment
- */
-
-import * as dotenv from 'dotenv';
-
-// Load test environment variables from root .env.test
-dotenv.config({ path: './.env.test' });
diff --git a/realtime-service/__tests__/test-setup.ts b/realtime-service/__tests__/test-setup.ts
deleted file mode 100644
index 682ad56..0000000
--- a/realtime-service/__tests__/test-setup.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Jest setupFilesAfterEnv configuration
- * This runs after the test framework is installed
- */
-
-// Mock the logger to prevent console output during tests
-jest.mock('../src/logger', () => ({
-  default: {
-    info: jest.fn(),
-    debug: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    trace: jest.fn(),
-    fatal: jest.fn(),
-  },
-}));
-
-// Mock log-helpers
-jest.mock('../src/log-helpers', () => ({
-  formatContext: jest.fn((context: any) => JSON.stringify(context)),
-  formatSession: jest.fn((session: any) => JSON.stringify(session)),
-  formatWorkspace: jest.fn((workspace: any) => JSON.stringify(workspace)),
-}));
-
-// Set up common test behaviors
-beforeEach(() => {
-  jest.clearAllMocks();
-});
-
-// Global test timeout
-jest.setTimeout(30000);
-
diff --git a/realtime-service/__tests__/utils/graph-test-helpers.ts b/realtime-service/__tests__/utils/graph-test-helpers.ts
deleted file mode 100644
index efc24db..0000000
--- a/realtime-service/__tests__/utils/graph-test-helpers.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Helper utilities for testing graph-related components
- */
-
-import { GraphBuilder } from '@inworld/runtime/graph';
-
-/**
- * Creates a mock GraphBuilder for testing
- */
-export function createMockGraphBuilder(graphId: string = 'test-graph') {
-  const nodes: any[] = [];
-  const edges: any[] = [];
-
-  const builder = {
-    addNode: jest.fn((node: any) => {
-      nodes.push(node);
-      return builder;
-    }),
-    addEdge: jest.fn((from: any, to: any, options?: any) => {
-      edges.push({ from, to, options });
-      return builder;
-    }),
-    setStartNode: jest.fn((node: any) => {
-      return builder;
-    }),
-    setEndNode: jest.fn((node: any) => {
-      return builder;
-    }),
-    build: jest.fn(() => ({
-      id: graphId,
-      nodes,
-      edges,
-      start: jest.fn(),
-      stop: jest.fn(),
-      execute: jest.fn(),
-    })),
-  };
-
-  return builder;
-}
-
-/**
- * Creates a mock Graph instance
- */
-export function createMockGraph(graphId: string = 'test-graph') {
-  return {
-    id: graphId,
-    start: jest.fn().mockResolvedValue(undefined),
-    stop: jest.fn().mockResolvedValue(undefined),
-    execute: jest.fn().mockResolvedValue(undefined),
-    getNodeById: jest.fn(),
-    getAllNodes: jest.fn(() => []),
-  };
-}
-
-/**
- * Helper to wait for async operations in tests
- */
-export async function waitForAsync(ms: number = 0): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Helper to create a mock async iterator for streaming data
- */
-export async function* createMockAsyncIterator<T>(items: T[]): AsyncIterableIterator<T> {
-  for (const item of items) {
-    yield item;
-  }
-}
-
diff --git a/realtime-service/__tests__/utils/mock-helpers.ts b/realtime-service/__tests__/utils/mock-helpers.ts
deleted file mode 100644
index 73fd89d..0000000
--- a/realtime-service/__tests__/utils/mock-helpers.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Mock helpers for unit tests
- * These utilities help create mock objects for testing
- */
-
-import { ProcessContext } from '@inworld/runtime/graph';
-import { ConnectionsMap, State, Connection } from '../../types/index';
-
-/**
- * Creates a mock ProcessContext for testing
- */
-export function createMockProcessContext(datastoreData: Record<string, any> = {}): ProcessContext {
-  const datastore = new Map(Object.entries(datastoreData));
-  
-  return {
-    getDatastore: jest.fn(() => ({
-      get: jest.fn((key: string) => datastore.get(key)),
-      set: jest.fn((key: string, value: any) => datastore.set(key, value)),
-      has: jest.fn((key: string) => datastore.has(key)),
-      delete: jest.fn((key: string) => datastore.delete(key)),
-    })),
-    getNodeId: jest.fn(() => 'test-node-id'),
-    getGraphId: jest.fn(() => 'test-graph-id'),
-  } as any;
-}
-
-/**
- * Creates a mock State object for testing
- */
-export function createMockState(overrides: Partial<State> = {}): State {
-  return {
-    sessionId: overrides.sessionId || 'test-session-id',
-    interactionId: overrides.interactionId || 'test-interaction-id',
-    messages: overrides.messages || [],
-    eagerness: overrides.eagerness || 'medium',
-    ...overrides,
-  } as State;
-}
-
-/**
- * Creates a mock Connection object for testing
- */
-export function createMockConnection(
-  sessionId: string = 'test-session-id',
-  stateOverrides: Partial<State> = {}
-): Connection {
-  return {
-    sessionId,
-    state: createMockState({ sessionId, ...stateOverrides }),
-    unloaded: false,
-  } as Connection;
-}
-
-/**
- * Creates a mock ConnectionsMap for testing
- */
-export function createMockConnectionsMap(
-  sessions: string[] = ['test-session-id']
-): ConnectionsMap {
-  const connections: ConnectionsMap = {};
-  
-  sessions.forEach(sessionId => {
-    connections[sessionId] = createMockConnection(sessionId);
-  });
-  
-  return connections;
-}
-
-/**
- * Creates a mock DataStreamWithMetadata for testing
- */
-export function createMockDataStreamWithMetadata(metadata: Record<string, any> = {}) {
-  return {
-    getMetadata: jest.fn(() => metadata),
-    getData: jest.fn(() => Buffer.from('test-data')),
-    setMetadata: jest.fn(),
-  };
-}
-
-/**
- * Helper to create a spy on a logger
- */
-export function createLoggerSpy() {
-  return {
-    info: jest.fn(),
-    debug: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    trace: jest.fn(),
-    fatal: jest.fn(),
-  };
-}
-
diff --git a/realtime-service/jest.config.js b/realtime-service/jest.config.js
deleted file mode 100644
index 6865b24..0000000
--- a/realtime-service/jest.config.js
+++ /dev/null
@@ -1,34 +0,0 @@
-module.exports = {
-  clearMocks: true,
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testTimeout: 30000,
-  roots: ['<rootDir>/__tests__'],
-  testMatch: [
-    '**/__tests__/**/*.spec.ts',
-    '**/?(*.)+(spec).ts'
-  ],
-  transform: {
-    '^.+\\.ts$': ['ts-jest', {
-      tsconfig: 'tsconfig.test.json'
-    }]
-  },
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/dist/**',
-    '!src/node_modules/**',
-    '!src/index.ts',
-  ],
-  coverageDirectory: 'coverage',
-  coverageReporters: ['text', 'lcov', 'html'],
-  coveragePathIgnorePatterns: ['node_modules', 'dist', '__tests__'],
-  moduleFileExtensions: ['ts', 'js', 'json'],
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/src/$1',
-  },
-  setupFiles: ['<rootDir>/__tests__/setup.ts'],
-  setupFilesAfterEnv: ['<rootDir>/__tests__/test-setup.ts'],
-  modulePathIgnorePatterns: ['dist/', 'node_modules/'],
-  verbose: true,
-};
diff --git a/realtime-service/load-tests/README.md b/realtime-service/load-tests/README.md
deleted file mode 100644
index 3f10757..0000000
--- a/realtime-service/load-tests/README.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# Load Tests
-
-Load testing suite for the Inworld Realtime API service using k6.
-
-## Prerequisites
-
-- [k6](https://k6.io/docs/getting-started/installation/) installed
-
-## Available Test Scripts
-
-### Local Mock Environment
-- `npm run test:local:mock:small` - Small load test
-- `npm run test:local:mock:medium` - Medium load test
-- `npm run test:local:mock:large` - Large load test
-- `npm run test:local:mock:xlarge` - Extra large load test
-
-### Local Proxy Environment
-- `npm run test:local:proxy:small` - Small load test
-- `npm run test:local:proxy:medium` - Medium load test
-- `npm run test:local:proxy:large` - Large load test
-- `npm run test:local:proxy:xlarge` - Extra large load test
-
-### Local Realtime Service
-- `npm run test:local:realtime:small` - Small load test
-- `npm run test:local:realtime:medium` - Medium load test
-- `npm run test:local:realtime:xmedium` - Extra medium load test
-- `npm run test:local:realtime:x2medium` - 2x medium load test
-- `npm run test:local:realtime:x2mediumLong` - 2x medium long duration test
-- `npm run test:local:realtime:large` - Large load test
-- `npm run test:local:realtime:xlarge` - Extra large load test
-
-### Dev Environment
-- `npm run test:dev:realtime:small` - Small load test
-- `npm run test:dev:realtime:medium` - Medium load test
-- `npm run test:dev:realtime:large` - Large load test
-- `npm run test:dev:realtime:xlarge` - Extra large load test
-
-## Environment Variables
-
-- `INWORLD_API_KEY` - Base64 encoded API key for authentication (optional)
-- `ENV_NAME` - Target environment (local-mock, local-proxy, local-realtime, dev)
-- `SCENARIO` - Load scenario (small, medium, large, xlarge, etc.)
-- `USE_ITEM_DONE_FOR_LATENCY` - Use response.done for latency measurement for response.create (true/false)
-- `WAIT_FOR_RESPONSE` - Wait for response before sending next message (true/false)
-- `DEBUG` - Enable debug logging (true/false)
-- `USE_WORKSPACE_PER_VU` - Enable propagate `workspace-id` unique header per VU
-
-## Usage
-
-Run a test script:
-```bash
-npm run test:local:realtime:medium
-```
-
-Or run k6 directly with custom parameters:
-```bash
-k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=medium
-```
-
-For local load testing or for direct Realtime service testing, you can use env variable `USE_WORKSPACE_PER_VU=true`
-to emulate multiple workspace's requests.
diff --git a/realtime-service/load-tests/load_test.js b/realtime-service/load-tests/load_test.js
deleted file mode 100644
index b249d6e..0000000
--- a/realtime-service/load-tests/load_test.js
+++ /dev/null
@@ -1,425 +0,0 @@
-import ws from 'k6/ws';
-import {check} from 'k6';
-import {Rate, Trend, Counter} from 'k6/metrics';
-
-const connectionLatency = new Trend('ws_connection_latency', true);
-const responseLatency = new Trend('ws_response_latency', true);
-const connectionSuccessRate = new Rate('ws_connection_success');
-const messageSuccessRate = new Rate('ws_message_success');
-const messagesSentCounter = new Counter('ws_messages_sent_total');
-const messagesReceivedCounter = new Counter('ws_messages_received_total');
-const websocketErrorCounter = new Counter('websocket_errors_total');
-
-// Configuration from environment variables
-const INWORLD_API_KEY = __ENV.INWORLD_API_KEY || '';
-const VU_ID = __VU;
-const ENV_NAME = __ENV.ENV_NAME || 'local-mock';
-const IS_DEBUG = __ENV.DEBUG === 'true';
-const USE_WORKSPACE_PER_VU = __ENV.USE_WORKSPACE_PER_VU === 'true';
-const USE_ITEM_DONE_FOR_LATENCY = __ENV.USE_ITEM_DONE_FOR_LATENCY === 'true';
-const WAIT_FOR_RESPONSE = __ENV.WAIT_FOR_RESPONSE === 'true';
-
-let baseWsUrl;
-// Select the base URL based on the environment name
-switch (ENV_NAME.toLowerCase()) {
-  case 'local-proxy':
-    // local w-proxy
-    baseWsUrl = 'ws://localhost:8081/api/v1/realtime/session';
-    break;
-  case 'local-realtime':
-    // local realtime
-    baseWsUrl = 'ws://localhost:4000/session';
-    break;
-  case 'dev':
-    // dev Realtime service
-    baseWsUrl = 'wss://api.dev.inworld.ai:443/api/v1/realtime/session';
-    break;
-  case 'local-mock':
-  default:
-    // local mock web-socket server
-    baseWsUrl = 'ws://localhost:9002/api/v1/realtime/session';
-    break;
-}
-
-const WS_URL = `${baseWsUrl}?protocol=realtime`;
-console.log(`[Config] Running test against environment: ${ENV_NAME}. URL: ${WS_URL}`);
-console.log(`[Config] USE_ITEM_DONE_FOR_LATENCY: ${USE_ITEM_DONE_FOR_LATENCY} (latency for response.create will be measured from response.done)`);
-console.log(`[Config] WAIT_FOR_RESPONSE: ${WAIT_FOR_RESPONSE} (send next message only after receiving response to previous)`);
-
-// Messages to send
-const messages = [
-  {type: 'session.update', session: {instructions: 'You are a helpful assistant that speaks in a friendly tone.'}},
-  {type: 'session.update', session: {audio: {output: {voice: 'Alex'}}}},
-  {type: 'session.update', session: {output_modalities: ["text"]}},
-  {
-    type: 'conversation.item.create',
-    item: {type: 'message', role: 'user', content: [{type: 'input_text', text: 'What is 2+2?'}]}
-  },
-  {type: 'response.create'}
-];
-
-const scenarios = {
-  small: [
-    { duration: '5s', target: 1 },
-    { duration: '5s', target: 3 },
-    { duration: '5s', target: 5 },
-    { duration: '5s', target: 5 },
-    { duration: '5s', target: 0 },
-  ],
-
-  medium: [
-    { duration: '5s', target: 5 },
-    { duration: '5s', target: 8 },
-    { duration: '5s', target: 15 },
-    { duration: '10s', target: 15 },
-    { duration: '5s', target: 0 },
-  ],
-
-  xmedium: [
-    { duration: '5s', target: 10 },
-    { duration: '5s', target: 15 },
-    { duration: '5s', target: 25 },
-    { duration: '10s', target: 25 },
-    { duration: '5s', target: 0 },
-  ],
-
-  x2medium: [
-    { duration: '5s', target: 20 },
-    { duration: '5s', target: 30 },
-    { duration: '5s', target: 50 },
-    { duration: '10s', target: 50 },
-    { duration: '5s', target: 0 },
-  ],
-
-  x2mediumLong: [
-    { duration: '10s', target: 20 },
-    { duration: '10s', target: 30 },
-    { duration: '10s', target: 50 },
-    { duration: '30s', target: 50 },
-    { duration: '10s', target: 0 },
-  ],
-
-  large: [
-    { duration: '10s', target: 20 },
-    { duration: '10s', target: 50 },
-    { duration: '10s', target: 80 },
-    { duration: '10s', target: 100 },
-    { duration: '30s', target: 100 },
-    { duration: '10s', target: 0 },
-  ],
-
-  xlarge: [
-    { duration: '10s', target: 20 },
-    { duration: '10s', target: 50 },
-    { duration: '10s', target: 80 },
-    { duration: '10s', target: 100 },
-    { duration: '10s', target: 150 },
-    { duration: '10s', target: 200 },
-    { duration: '30s', target: 200 },
-    { duration: '10s', target: 0 },
-  ],
-};
-
-const scenarioName = __ENV.SCENARIO || "small";
-
-// Dynamically create metrics for each message
-const messageLatencies = [];
-const messageSuccessRates = [];
-
-for (let i = 0; i < messages.length; i++) {
-  const messageIndex = i + 1; // 1-based index for metric names
-  messageLatencies.push(new Trend(`message${messageIndex}_latency`, true));
-  messageSuccessRates.push(new Rate(`message${messageIndex}_success`));
-}
-
-export const options = {
-  stages: scenarios[scenarioName],
-  thresholds: {
-    'ws_connection_success': ['rate>0.95'],
-    'ws_message_success': ['rate>0.95'],
-    'ws_connection_latency': ['p(95)<1000'],
-    'ws_response_latency': ['p(95)<5000'],
-  },
-  summaryTrendStats: ["min", "max", "avg", "med", "p(90)", "p(95)", "p(99)", "p(99.9)"],
-};
-
-export default function () {
-  const sessionKey = `test-session-${VU_ID}-${Date.now()}`;
-  const url = `${WS_URL}&key=${sessionKey}`;
-  const params = {
-    tags: {name: 'WebSocket Connection'},
-    headers: {},
-  };
-  if (INWORLD_API_KEY) {
-    params.headers['Authorization'] = `Basic ${INWORLD_API_KEY}`;
-  }
-
-  if (USE_WORKSPACE_PER_VU) {
-    params.headers['workspace-id'] = `workspace-${VU_ID}}`;
-    console.log(`[VU ${VU_ID}] Using workspace-id: ${params.headers['workspace-id']}`);
-  }
-
-  const connectionStart = Date.now();
-
-  const response = ws.connect(url, params, function (socket) {
-    const connectionEnd = Date.now();
-    const connectionTime = connectionEnd - connectionStart;
-    connectionLatency.add(connectionTime);
-    connectionSuccessRate.add(1);
-
-    // Track message sending and response times
-    const pendingMessages = new Map();
-    const pendingResponseCreate = new Map();
-    let receivedMessageCount = 0;
-    let sessionCreatedReceived = false;
-    let allMessagesSent = false;
-    let currentMessageIndex = 0;
-
-    const sendMessage = function (index) {
-      if (index >= messages.length) {
-        allMessagesSent = true;
-        return;
-      }
-
-      const messageStart = Date.now();
-      const isResponseCreate = messages[index].type === 'response.create';
-
-      if (USE_ITEM_DONE_FOR_LATENCY && isResponseCreate) {
-        pendingResponseCreate.set(index, {sentTime: messageStart});
-      } else {
-        pendingMessages.set(index, {sentTime: messageStart, responded: false});
-      }
-
-      messagesSentCounter.add(1);
-      socket.send(JSON.stringify(messages[index]));
-
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] Sent message ${index + 1}/${messages.length}:`, messages[index].type);
-      }
-
-      socket.setTimeout(() => {
-        if (USE_ITEM_DONE_FOR_LATENCY && isResponseCreate) {
-          if (pendingResponseCreate.has(index)) {
-            pendingResponseCreate.delete(index);
-            messageSuccessRate.add(0);
-            if (index >= 0 && index < messageSuccessRates.length) {
-              messageSuccessRates[index].add(0);
-            }
-            if (IS_DEBUG) {
-              console.log(`[VU ${VU_ID}] Timeout waiting for response.done for message ${index + 1}`);
-            }
-          }
-        } else {
-          if (pendingMessages.has(index) && !pendingMessages.get(index).responded) {
-            pendingMessages.delete(index);
-            messageSuccessRate.add(0);
-            if (index >= 0 && index < messageSuccessRates.length) {
-              messageSuccessRates[index].add(0);
-            }
-            if (IS_DEBUG) {
-              console.log(`[VU ${VU_ID}] Timeout waiting for response to message ${index + 1}`);
-            }
-          }
-        }
-      }, 10000);
-    };
-
-    socket.on('open', () => {
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] WebSocket connection opened to url ${url}`);
-      }
-
-      // Send the first message immediately
-      if (messages.length > 0) {
-        sendMessage(0);
-        currentMessageIndex = 1;
-      }
-
-      if (!WAIT_FOR_RESPONSE) {
-        // In timed mode, send messages with delays
-        for (let index = 1; index < messages.length; index++) {
-          socket.setTimeout(() => {
-            sendMessage(index);
-          }, index * 50);
-        }
-
-        socket.setTimeout(() => {
-          allMessagesSent = true;
-        }, (messages.length - 1) * 50);
-      }
-    });
-
-    socket.on('message', (data) => {
-      const ts = Date.now();
-      messagesReceivedCounter.add(1);
-
-      let msg;
-      try { msg = JSON.parse(data); }
-      catch { if (IS_DEBUG) console.log("Non-JSON message"); return; }
-
-      const type = msg.type || "unknown";
-      if (IS_DEBUG) console.log(`[VU ${VU_ID}] Received: ${type}`);
-
-      if (type === 'session.created') {
-        sessionCreatedReceived = true;
-        return;
-      }
-
-      if (USE_ITEM_DONE_FOR_LATENCY && type === "response.done") {
-        handleResponseDone(ts);
-      } else {
-        handleRegularResponse(ts);
-      }
-
-      attemptSendNextMessage();
-      tryCloseSocket();
-    });
-
-
-    function handleResponseDone(ts) {
-      if (pendingResponseCreate.size === 0) {
-        if (IS_DEBUG) console.log("response.done received without a pending response.create");
-        return;
-      }
-
-      const [index, entry] = [...pendingResponseCreate.entries()].sort(([a],[b]) => a - b)[0];
-      pendingResponseCreate.delete(index);
-
-      const latency = Math.max(0, ts - entry.sentTime);
-      recordSuccess(index, latency);
-
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] response.done matched message ${index+1}, latency: ${latency}ms`);
-      }
-    }
-
-    function handleRegularResponse(ts) {
-      if (pendingMessages.size === 0) {
-        if (IS_DEBUG) console.log("Response w/o pendingMessages");
-        return;
-      }
-
-      const [index, entry] = [...pendingMessages.entries()].sort(([a],[b]) => a - b)[0];
-      pendingMessages.delete(index);
-
-      let latency = ts - entry.sentTime;
-      if (latency < 0) latency = 0;
-      if (latency === 0) latency = 0.5;
-
-      recordSuccess(index, latency);
-
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] matched response for message ${index+1}, latency: ${latency}ms`);
-      }
-    }
-
-    function recordSuccess(index, latency) {
-      responseLatency.add(latency);
-      messageSuccessRate.add(1);
-
-      if (index >= 0 && index < messageLatencies.length) {
-        messageLatencies[index].add(latency);
-        messageSuccessRates[index].add(1);
-      }
-    }
-
-    function attemptSendNextMessage() {
-      if (!WAIT_FOR_RESPONSE) return;
-      if (currentMessageIndex >= messages.length) return;
-
-      socket.setTimeout(() => {
-        sendMessage(currentMessageIndex);
-        currentMessageIndex++;
-        if (currentMessageIndex >= messages.length) allMessagesSent = true;
-      }, 50);
-    }
-
-    function tryCloseSocket() {
-      const pendingCount =
-        pendingMessages.size +
-        (USE_ITEM_DONE_FOR_LATENCY ? pendingResponseCreate.size : 0);
-
-      if (!allMessagesSent || pendingCount > 0) return;
-
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] All responses received. Closing socket.`);
-      }
-
-      socket.close();
-    }
-
-    socket.on('error', function (e) {
-      console.error(`[VU ${VU_ID}] WebSocket error:`, e.error());
-      websocketErrorCounter.add(1);
-      connectionSuccessRate.add(0);
-      check(false, {'WebSocket connection must not have errors': e.error() == undefined});
-    });
-
-    socket.on('close', () => {
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] Connection closed`);
-      }
-
-      for (const [msgIndex, entry] of pendingMessages.entries()) {
-        if (!entry.responded) {
-          messageSuccessRate.add(0);
-          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
-            messageSuccessRates[msgIndex].add(0);
-          }
-        }
-      }
-      pendingMessages.clear();
-
-      if (USE_ITEM_DONE_FOR_LATENCY) {
-        for (const [msgIndex, entry] of pendingResponseCreate.entries()) {
-          messageSuccessRate.add(0);
-          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
-            messageSuccessRates[msgIndex].add(0);
-          }
-        }
-        pendingResponseCreate.clear();
-      }
-    });
-
-    const safetyTimeout = (messages.length * 1000) + 1000;
-
-    socket.setTimeout(() => {
-      const pendingCount = pendingMessages.size + (USE_ITEM_DONE_FOR_LATENCY ? pendingResponseCreate.size : 0);
-      if (IS_DEBUG) {
-        console.log(`[VU ${VU_ID}] Safety timeout - closing connection. Sent: ${messages.length}, Received: ${receivedMessageCount}, Pending: ${pendingCount}`);
-      }
-
-      for (const [msgIndex, entry] of pendingMessages.entries()) {
-        if (!entry.responded) {
-          messageSuccessRate.add(0);
-          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
-            messageSuccessRates[msgIndex].add(0);
-          }
-        }
-      }
-      pendingMessages.clear();
-
-      if (USE_ITEM_DONE_FOR_LATENCY) {
-        for (const [msgIndex, entry] of pendingResponseCreate.entries()) {
-          messageSuccessRate.add(0);
-          if (msgIndex >= 0 && msgIndex < messageSuccessRates.length) {
-            messageSuccessRates[msgIndex].add(0);
-          }
-        }
-        pendingResponseCreate.clear();
-      }
-
-      socket.close();
-    }, safetyTimeout);
-  });
-
-  check(response, {
-    'WebSocket connection established': (r) => r && r.status === 101,
-  }, {name: 'Connection Check'});
-
-  if (!response || response.status !== 101) {
-    connectionSuccessRate.add(0);
-    const connectionTime = Date.now() - connectionStart;
-    connectionLatency.add(connectionTime);
-  }
-}
diff --git a/realtime-service/load-tests/package.json b/realtime-service/load-tests/package.json
deleted file mode 100644
index 166852b..0000000
--- a/realtime-service/load-tests/package.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-  "name": "load-tests",
-  "version": "1.0.0",
-  "description": "",
-  "scripts": {
-    "test:local:mock:small": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=small -e USE_ITEM_DONE_FOR_LATENCY=false",
-    "test:local:mock:medium": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=medium -e USE_ITEM_DONE_FOR_LATENCY=false",
-    "test:local:mock:large": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=large -e USE_ITEM_DONE_FOR_LATENCY=false",
-    "test:local:mock:xlarge": "k6 run load_test.js -e ENV_NAME=local-mock -e SCENARIO=xlarge -e USE_ITEM_DONE_FOR_LATENCY=false",
-
-    "test:local:proxy:small": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=small -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:proxy:medium": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:proxy:large": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=large -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:proxy:xlarge": "k6 run load_test.js -e ENV_NAME=local-proxy -e SCENARIO=xlarge -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-
-    "test:local:realtime:small": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=small -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:medium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:xmedium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=xmedium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:x2medium": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=x2medium -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:x2mediumLong": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=x2mediumLong -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:large": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=large -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:local:realtime:xlarge": "k6 run load_test.js -e ENV_NAME=local-realtime -e SCENARIO=xlarge -e WAIT_FOR_RESPONSE=true -e USE_ITEM_DONE_FOR_LATENCY=true",
-
-    "test:dev:realtime:small": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=small -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:dev:realtime:medium": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=medium -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:dev:realtime:large": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=large -e USE_ITEM_DONE_FOR_LATENCY=true",
-    "test:dev:realtime:xlarge": "k6 run load_test.js -e ENV_NAME=dev -e SCENARIO=xlarge -e USE_ITEM_DONE_FOR_LATENCY=true"
-  },
-  "private": true
-}
diff --git a/realtime-service/mock/echo_ws_server.go b/realtime-service/mock/echo_ws_server.go
deleted file mode 100644
index 09c95e8..0000000
--- a/realtime-service/mock/echo_ws_server.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gorilla/websocket"
-)
-
-var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool {
-		return true
-	},
-}
-
-func echoServer(w http.ResponseWriter, r *http.Request) {
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Println("Upgrade failed:", err)
-		return
-	}
-	defer conn.Close()
-
-	log.Println("Client connected!")
-
-	for {
-		messageType, message, err := conn.ReadMessage()
-		if err != nil {
-			log.Println("Read failed:", err)
-			break
-		}
-
-		log.Printf("Received: %s", message)
-
-		err = conn.WriteMessage(messageType, message)
-		if err != nil {
-			log.Println("Write failed:", err)
-			break
-		}
-	}
-}
-
-func main() {
-	http.HandleFunc("/session", echoServer)
-	log.Println("WebSocket Mock Server starting on :4000/ws")
-	err := http.ListenAndServe(":4000", nil)
-	if err != nil {
-		log.Fatal("ListenAndServe: ", err)
-	}
-}
diff --git a/realtime-service/package-lock.json b/realtime-service/package-lock.json
deleted file mode 100644
index fa4ab77..0000000
--- a/realtime-service/package-lock.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
-  "name": "animations-inc-voice-agent",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "dependencies": {
-        "ws": "^8.18.3"
-      }
-    },
-    "node_modules/ws": {
-      "version": "8.18.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
-      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}
diff --git a/realtime-service/package.json b/realtime-service/package.json
deleted file mode 100644
index 2bb8f52..0000000
--- a/realtime-service/package.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "name": "realtime-service",
-  "version": "1.0.0",
-  "description": "Realtime service with unit testing support",
-  "scripts": {
-    "test": "WS_APP_PORT=4000 jest",
-    "test:api": "WS_APP_PORT=4000 jest __tests__/api",
-    "test:watch": "WS_APP_PORT=4000 jest --watch",
-    "test:coverage": "WS_APP_PORT=4000 jest --coverage",
-    "test:verbose": "WS_APP_PORT=4000 jest --verbose"
-  },
-  "dependencies": {
-    "uuid": "^11.1.0",
-    "ws": "^8.18.3"
-  },
-  "devDependencies": {
-    "@types/jest": "^29.5.11",
-    "@types/node": "^20.10.6",
-    "@types/uuid": "^9.0.0",
-    "@types/ws": "^8.5.10",
-    "dotenv": "^16.4.7",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.3.3"
-  }
-}
diff --git a/realtime-service/src/.gitignore b/realtime-service/src/.gitignore
deleted file mode 100644
index 67c86a3..0000000
--- a/realtime-service/src/.gitignore
+++ /dev/null
@@ -1,32 +0,0 @@
-# TypeScript build output
-dist/
-
-# Dependencies
-node_modules/
-
-# Environment variables
-.env
-.env.local
-.env.*.local
-
-# Logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# OS
-.DS_Store
-Thumbs.db
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# Testing
-coverage/
-.nyc_output/
-
diff --git a/realtime-service/src/REALTIME_API.md b/realtime-service/src/REALTIME_API.md
deleted file mode 100644
index 2c7b371..0000000
--- a/realtime-service/src/REALTIME_API.md
+++ /dev/null
@@ -1,313 +0,0 @@
-# OpenAI Realtime API Implementation
-
-This server now supports the OpenAI Realtime API protocol for WebSocket-based real-time voice and audio interactions.
-
-## Protocol Selection
-
-The server previously supports two protocols:
-
-1. **Legacy Protocol** (default): The original custom protocol
-2. **Realtime Protocol**: OpenAI Realtime API compatible protocol
-
-The legacy protocol is no longer supported. We now support serving realtime events through OpenAI compatible API events with a few exceptions.
-
-To use the Realtime protocol, add `protocol=realtime` as a query parameter when connecting to the WebSocket:
-
-```
-ws://YOUR_API_HOST:PORT/session?protocol=realtime&key=YOUR_SESSION_KEY
-```
-
-## Connection Flow
-
-
-### 1. Connect via WebSocket
-
-Connect to the WebSocket endpoint with the Realtime protocol:
-
-```javascript
-const ws = new WebSocket('ws://YOUR_API_HOST:PORT/session?protocol=realtime&key=YOUR_SESSION_KEY');
-
-ws.onopen = () => {
-  console.log('Connected');
-  handleOpen();
-};
-
-ws.onmessage = (event) => this.handleMessage(event);
-ws.onerror = (error) => this.handleError(error);
-ws.onclose = () => this.handleClose();
-
-```
-
-### 2. Send session.update Event
-
-You should send a session.update Event when the websocket opens, just like when you are using OpenAI API.
-
-```javascript
-const sessionUpdate = {
-      type: 'session.update',
-      session: {
-        type: 'realtime',  // Required by OpenAI API
-        output_modalities: modalities,
-        instructions: instructions,
-        tools: tools,
-        tool_choice: toolChoice,
-        audio: {
-          input: {
-            turn_detection: {
-              type: 'semantic_vad',
-              eagerness: eagerness,
-              create_response: true,
-              interrupt_response: false,
-            },
-            transcription: {
-              model: 'gpt-4o-mini-transcribe',
-            },
-          },
-          output: {
-            voice: voice,  // Selected voice from dropdown
-          },
-        },
-      },
-    };
-```
-
-You will then be able to send Client Events and receive responses from the server.
-
-## Client Events
-
-### Update Session Configuration
-
-We support partial update to session such as:
-
-```javascript
-ws.send(JSON.stringify({
-  type: 'session.update',
-  session: {
-    instructions: 'You are a friendly assistant',
-    voice: 'Hades',
-    temperature: 0.7
-  }
-}));
-```
-
-### Send Audio Input
-
-The Realtime API uses PCM16 audio at 24kHz sample rate.
-
-```javascript
-// Append audio to input buffer
-ws.send(JSON.stringify({
-  type: 'input_audio_buffer.append',
-  audio: base64AudioData  // base64-encoded PCM16 audio at 24kHz
-}));
-
-// Manually commit the audio buffer (not needed with server VAD)
-ws.send(JSON.stringify({
-  type: 'input_audio_buffer.commit'
-}));
-```
-
-### Create a Text Message
-
-```javascript
-ws.send(JSON.stringify({
-  type: 'conversation.item.create',
-  item: {
-    type: 'message',
-    role: 'user',
-    content: [
-      {
-        type: 'input_text',
-        text: 'Hello, how are you?'
-      }
-    ]
-  }
-}));
-
-// Trigger a response
-ws.send(JSON.stringify({
-  type: 'response.create'
-}));
-```
-
-### Cancel a Response
-
-```javascript
-ws.send(JSON.stringify({
-  type: 'response.cancel'
-}));
-```
-
-### Delete / Retrieve a Response via Item ID
-
-```javascript
-ws.send(JSON.stringify({
-    type: 'conversation.item.delete',
-    item_id: itemId,
-}));
-```
-
-```javascript
-ws.send(JSON.stringify({
-    type: 'conversation.item.retrieve',
-    item_id: itemId,
-}));
-```
-
-The item id will be generated by the server in the corresponding event sent back (such as `response.created`).
-
-We have covered all client events available in OpenAI Websocket Protocol, except for `conversation.item.truncate`. 
-
-## Server Events
-
-The server will send various events during the conversation:
-
-### Audio Response Flow
-
-Here's a sequence of events that will be sent back upon the server receiving audio buffer commits.
-
-1. `response.created` - Response generation started
-2. `response.output_item.added` - Output item created
-3. `response.content_part.added` - Content part (audio) added
-4. `response.audio_transcript.delta` - Transcript chunks (streaming)
-5. `response.audio.delta` - Audio chunks (streaming, base64-encoded WAV)
-6. `response.audio_transcript.done` - Transcript complete
-7. `response.audio.done` - Audio complete
-8. `response.content_part.done` - Content part complete
-9. `response.output_item.done` - Output item complete
-10. `response.done` - Response complete
-
-Refer to our API Reference for contents of such events.
-
-### Voice Activity Detection (VAD) Events
-
-When server VAD is enabled (default), instead of buffer commits, the server will decide when to create the conversation item.
-
-As such, events that informs the client will be prepended to the above flow.
-
-1. `input_audio_buffer.speech_started` - Speech detected
-2. `input_audio_buffer.speech_stopped` - Speech ended
-3. `input_audio_buffer.committed` - Audio buffer committed
-4. `conversation.item.created` - User message item created
-5. Response flow (see above)
-
-## Audio Format
-
-- **Input**: PCM16, 24kHz, mono, base64-encoded
-- **Output**: WAV format, base64-encoded (contains PCM16 at 24kHz)
-
-## Example: Simple Audio Conversation
-
-```javascript
-const ws = new WebSocket('ws://localhost:4000/session?key=my-session&protocol=realtime');
-
-ws.onmessage = (event) => {
-  const msg = JSON.parse(event.data);
-
-  switch (msg.type) {
-    case 'session.created':
-      console.log('Session ready');
-      // Start sending audio
-      break;
-
-    case 'input_audio_buffer.speech_started':
-      console.log('User started speaking');
-      break;
-
-    case 'input_audio_buffer.speech_stopped':
-      console.log('User stopped speaking');
-      break;
-
-    case 'response.audio.delta':
-      // Decode and play audio
-      const audioBuffer = Buffer.from(msg.delta, 'base64');
-      playAudio(audioBuffer);
-      break;
-
-    case 'response.audio_transcript.delta':
-      console.log('Assistant:', msg.delta);
-      break;
-
-    case 'response.done':
-      console.log('Response complete');
-      break;
-
-    case 'error':
-      console.error('Error:', msg.error);
-      break;
-  }
-};
-
-// Send audio chunks
-function sendAudioChunk(pcm16Data) {
-  ws.send(JSON.stringify({
-    type: 'input_audio_buffer.append',
-    audio: pcm16Data.toString('base64')
-  }));
-}
-```
-
-## Configuration
-
-### Server VAD (Voice Activity Detection)
-
-By default, server VAD is enabled with these settings:
-
-- **threshold**: 0.5 (voice detection sensitivity)
-- **prefix_padding_ms**: 300 (audio to include before speech)
-- **silence_duration_ms**: 500 (silence duration to detect end of speech)
-- **create_response**: true (automatically create response when speech ends)
-- Alternatively, use eagerness for presets that fits different purposes. (`'low' | 'medium' | 'high'`) The higher eagerness, the more easily for the server to conclude your conversation round.
-
-You can update these settings using `session.update`:
-
-```javascript
-ws.send(JSON.stringify({
-  type: 'session.update',
-  session: {
-    turn_detection: {
-      type: 'server_vad',
-      threshold: 0.7,
-      silence_duration_ms: 800,
-      // eagerness: 'high',
-    }
-  }
-}));
-```
-
-To disable server VAD:
-
-```javascript
-ws.send(JSON.stringify({
-  type: 'session.update',
-  session: {
-    turn_detection: null
-  }
-}));
-```
-
-## Error Handling
-
-Errors are sent as `error` events:
-
-```json
-{
-  "event_id": "evt_789",
-  "type": "error",
-  "error": {
-    "type": "invalid_request_error",
-    "code": "invalid_event",
-    "message": "Input audio buffer is empty",
-    "param": null,
-    "event_id": "evt_123"
-  }
-}
-```
-
-## Differences from OpenAI's Implementation
-
-This implementation provides compatibility with the OpenAI Realtime API protocol while using different backend services:
-
-- Uses custom LLM and TTS models (configured via environment variables)
-- Audio processing handled by Inworld Runtime graphs
-- Some advanced features (like function calling) may have different behavior
diff --git a/realtime-service/src/components/app.ts b/realtime-service/src/components/app.ts
deleted file mode 100644
index d22dbd0..0000000
--- a/realtime-service/src/components/app.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import logger from '../logger';
-import { Connection } from '../types/index';
-import { InworldGraphWrapper } from './graphs/graph';
-import { InworldAppConfig } from './runtime_app_manager';
-import { DEFAULT_LLM_MODEL_NAME, DEFAULT_LLM_PROVIDER, DEFAULT_VOICE_ID, DEFAULT_TTS_MODEL_ID } from '../config';
-
-export class InworldApp {
-  graphId?: string;
-  llmModelName: string;
-  llmProvider: string;
-  voiceId: string;
-  graphVisualizationEnabled: boolean;
-  ttsModelId: string;
-  assemblyAIApiKey: string;
-  useMocks: boolean;
-  connections: {
-    [sessionId: string]: Connection;
-  } = {};
-
-  graphWithAudioInput: InworldGraphWrapper;
-
-  private constructor(config: InworldAppConfig) {
-    this.graphId = config.graphId;
-    this.llmModelName = config.llmModelName || DEFAULT_LLM_MODEL_NAME;
-    this.llmProvider = config.llmProvider || DEFAULT_LLM_PROVIDER;
-    this.voiceId = config.voiceId || DEFAULT_VOICE_ID;
-    this.ttsModelId = config.ttsModelId || DEFAULT_TTS_MODEL_ID;
-    this.graphVisualizationEnabled = config.graphVisualizationEnabled!;
-    this.assemblyAIApiKey = config.assemblyAIApiKey || '';
-    this.useMocks = config.useMocks ?? false;
-
-    // Use shared connections if provided, otherwise create own
-    this.connections = config.sharedConnections || {};
-  }
-
-  /**
-   * Factory method to create and initialize an InworldApp instance
-   * Use this instead of calling the constructor directly
-   */
-  static async create(config: InworldAppConfig): Promise<InworldApp> {
-    const app = new InworldApp(config);
-    await app.initialize();
-    return app;
-  }
-
-  private async initialize() {
-    // Create audio graph with Assembly.AI STT (handles both audio and text inputs)
-    this.graphWithAudioInput = await InworldGraphWrapper.create({
-      llmModelName: this.llmModelName,
-      llmProvider: this.llmProvider,
-      voiceId: this.voiceId,
-      connections: this.connections,
-      graphVisualizationEnabled: this.graphVisualizationEnabled,
-      ttsModelId: this.ttsModelId,
-      useAssemblyAI: true,
-      assemblyAIApiKey: this.assemblyAIApiKey,
-      useMocks: this.useMocks,
-    });
-
-    logger.info('✓ Audio input graph initialized (Assembly.AI STT)');
-  }
-
-  /**
-   * Remove a session and clean up its connection
-   */
-  removeSession(sessionId: string): void {
-    delete this.connections[sessionId];
-  }
-
-  async shutdown() {
-    // Clear all connections
-    Object.keys(this.connections).forEach(sessionId => {
-      delete this.connections[sessionId];
-    });
-
-    await this.graphWithAudioInput.destroy();
-  }
-}
diff --git a/realtime-service/src/components/audio/audio_utils.ts b/realtime-service/src/components/audio/audio_utils.ts
deleted file mode 100644
index c11dad3..0000000
--- a/realtime-service/src/components/audio/audio_utils.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * Audio utility functions for converting between audio formats
- */
-import logger from '../../logger';
-
-/**
- * Convert Float32Array (-1.0 to 1.0) to Int16Array PCM16 (-32768 to 32767)
- * @param float32Data - Input audio data as Float32Array
- * @returns Int16Array containing PCM16 audio data
- */
-export function float32ToPCM16(float32Data: Float32Array): Int16Array {
-  const pcm16 = new Int16Array(float32Data.length);
-  for (let i = 0; i < float32Data.length; i++) {
-    // Clamp values to [-1, 1] range
-    const clamped = Math.max(-1, Math.min(1, float32Data[i]));
-    // Convert to 16-bit PCM
-    pcm16[i] = clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff;
-  }
-  return pcm16;
-}
-
-/**
- * Convert audio data to PCM16 base64 format for OpenAI Realtime API
- * @param audioData - Audio data in various formats (array, Buffer, Float32Array, base64 string)
- * @param sampleRate - Sample rate of the audio (for logging purposes)
- * @param debugLabel - Label for debug logging
- * @returns Base64 encoded PCM16 audio data, or null if conversion fails
- */
-export function convertToPCM16Base64(
-  audioData: any,
-  sampleRate?: number,
-  debugLabel: string = 'Audio',
-): string | null {
-  if (!audioData) {
-    logger.error({ debugLabel }, 'Audio Utils - No audio data provided');
-    return null;
-  }
-
-  // Convert audio data to Float32Array based on its actual type
-  let floatSamples: Float32Array;
-
-  if (Array.isArray(audioData)) {
-    // The array contains byte values from a Buffer, not float values
-    // Interpret these bytes as Float32 data (4 bytes per float)
-    // console.log(`[${debugLabel}] Converting byte array to Float32Array`);
-    const byteBuffer = Buffer.from(audioData);
-    floatSamples = new Float32Array(
-      byteBuffer.buffer,
-      byteBuffer.byteOffset,
-      byteBuffer.length / 4,
-    );
-  } else if (Buffer.isBuffer(audioData)) {
-    // If it's already a Buffer
-    logger.debug({ debugLabel }, 'Audio Utils - Converting Buffer to Float32Array');
-    floatSamples = new Float32Array(
-      audioData.buffer,
-      audioData.byteOffset,
-      audioData.length / 4,
-    );
-  } else if (audioData instanceof Float32Array) {
-    // Already Float32Array
-    logger.debug({ debugLabel }, 'Audio Utils - Using existing Float32Array');
-    floatSamples = audioData;
-  } else if (typeof audioData === 'string') {
-    // If it's a base64 string (legacy format)
-    logger.debug({ debugLabel }, 'Audio Utils - Decoding base64 string to Float32Array');
-    const decodedData = Buffer.from(audioData, 'base64');
-    floatSamples = new Float32Array(
-      decodedData.buffer,
-      decodedData.byteOffset,
-      decodedData.length / 4,
-    );
-  } else {
-    logger.error({ debugLabel, dataType: typeof audioData }, `Audio Utils - Unsupported audio data type: ${typeof audioData}`);
-    return null;
-  }
-
-  // Validate Float32Array has data
-  if (floatSamples.length === 0) {
-    logger.warn({ debugLabel }, 'Audio Utils - Skipping zero-length audio samples');
-    return null;
-  }
-
-  // Convert Float32 (-1.0 to 1.0) to PCM16 (-32768 to 32767)
-  const pcm16 = float32ToPCM16(floatSamples);
-
-  const audioBase64 = Buffer.from(pcm16.buffer).toString('base64');
-  logger.debug({ debugLabel, length: audioBase64.length }, 'Audio Utils - Sending base64 audio');
-
-  return audioBase64;
-}
diff --git a/realtime-service/src/components/audio/multimodal_stream_manager.ts b/realtime-service/src/components/audio/multimodal_stream_manager.ts
deleted file mode 100644
index 8c5d5c6..0000000
--- a/realtime-service/src/components/audio/multimodal_stream_manager.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { AudioChunkInterface } from '@inworld/runtime/common';
-import { GraphTypes } from '@inworld/runtime/graph';
-
-import logger from '../../logger';
-
-/**
- * Manages a stream of multimodal content (audio and/or text) that can be fed
- * asynchronously as data arrives from websocket connections.
- *
- * This unifies audio and text streaming into a single interface that always
- * yields MultimodalContent, making it compatible with entry node routing.
- */
-export class MultimodalStreamManager {
-  private queue: GraphTypes.MultimodalContent[] = [];
-  private waitingResolvers: Array<
-    (value: IteratorResult<GraphTypes.MultimodalContent>) => void
-  > = [];
-  private ended = false;
-
-  /**
-   * Add an audio chunk to the stream (wrapped in MultimodalContent)
-   */
-  pushAudio(chunk: AudioChunkInterface): void {
-    if (this.ended) {
-      return;
-    }
-
-    // Create GraphTypes.Audio object and wrap in MultimodalContent
-    const audioData = new GraphTypes.Audio({
-      data: Array.isArray(chunk.data) ? chunk.data : Array.from(chunk.data),
-      sampleRate: chunk.sampleRate,
-    });
-    const multimodalContent = new GraphTypes.MultimodalContent({
-      audio: audioData,
-    });
-
-    this.pushContent(multimodalContent);
-  }
-
-  /**
-   * Add text to the stream (wrapped in MultimodalContent)
-   */
-  pushText(text: string): void {
-    if (this.ended) {
-      return;
-    }
-
-    const multimodalContent = new GraphTypes.MultimodalContent({ text });
-    this.pushContent(multimodalContent);
-  }
-
-  /**
-   * Internal method to push MultimodalContent to the stream
-   */
-  private pushContent(content: GraphTypes.MultimodalContent): void {
-    // If there are waiting consumers, resolve immediately
-    if (this.waitingResolvers.length > 0) {
-      const resolve = this.waitingResolvers.shift()!;
-      resolve({ value: content, done: false });
-    } else {
-      // Otherwise, queue the content
-      this.queue.push(content);
-    }
-  }
-
-  /**
-   * Mark the stream as ended
-   */
-  end(): void {
-    logger.info('[MultimodalStreamManager] Ending stream');
-    this.ended = true;
-
-    // Resolve all waiting consumers with done signal
-    while (this.waitingResolvers.length > 0) {
-      const resolve = this.waitingResolvers.shift()!;
-      resolve({ value: undefined as any, done: true });
-    }
-  }
-
-  /**
-   * Create an async iterator for the stream
-   */
-  async *createStream(): AsyncIterableIterator<GraphTypes.MultimodalContent> {
-    while (true) {
-      // If stream ended and queue is empty, we're done
-      if (this.ended && this.queue.length === 0) {
-        logger.info('[MultimodalStreamManager] Stream iteration complete');
-        return;
-      }
-
-      // If we have queued content, yield it immediately
-      if (this.queue.length > 0) {
-        const content = this.queue.shift()!;
-        yield content;
-        continue;
-      }
-
-      // If stream ended but we just exhausted the queue, we're done
-      if (this.ended) {
-        logger.info('[MultimodalStreamManager] Stream iteration complete');
-        return;
-      }
-
-      // Otherwise, wait for new content
-      const result = await new Promise<
-        IteratorResult<GraphTypes.MultimodalContent>
-      >((resolve) => {
-        this.waitingResolvers.push(resolve);
-      });
-
-      if (result.done) {
-        return;
-      }
-
-      yield result.value;
-    }
-  }
-
-  /**
-   * Check if the stream has ended
-   */
-  isEnded(): boolean {
-    return this.ended;
-  }
-}
diff --git a/realtime-service/src/components/audio/realtime_audio_handler.ts b/realtime-service/src/components/audio/realtime_audio_handler.ts
deleted file mode 100644
index 9615b64..0000000
--- a/realtime-service/src/components/audio/realtime_audio_handler.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-import logger from '../../logger';
-import { formatSession, formatError } from '../../log-helpers';
-import { INPUT_SAMPLE_RATE } from '../../config';
-import * as RT from '../../types/realtime';
-import { InworldApp } from '../app';
-import { MultimodalStreamManager } from './multimodal_stream_manager';
-import { RealtimeEventFactory } from '../realtime/realtime_event_factory';
-import { RealtimeGraphExecutor } from '../graphs/realtime_graph_executor';
-import { RealtimeSessionManager } from '../realtime/realtime_session_manager';
-
-export class RealtimeAudioHandler {
-  constructor(
-    private inworldApp: InworldApp,
-    private sessionKey: string,
-    private send: (data: RT.ServerEvent) => void,
-    private graphExecutor: RealtimeGraphExecutor,
-    private sessionManager: RealtimeSessionManager
-  ) {}
-
-  /**
-   * Ensures that the audio graph execution is running.
-   * Creates the multimodal stream manager and starts the graph execution if not already running.
-   * @param connection - The connection object to initialize
-   * @param context - Context string for logging (e.g., 'Audio', 'Text Input')
-   */
-  private ensureAudioGraphExecution(
-    connection: NonNullable<typeof this.inworldApp.connections[string]>,
-    context: string = 'Audio'
-  ): void {
-    if (connection.multimodalStreamManager) {
-      return;
-    }
-
-    connection.multimodalStreamManager = new MultimodalStreamManager();
-
-    const session = this.sessionManager.getSession();
-
-    // Start the audio graph execution with the stream
-    const audioStreamInput = {
-      sessionId: this.sessionKey,
-      state: connection.state,
-      voiceId: connection.state.voiceId || session.session.audio.output.voice,
-    };
-
-    // Use the Assembly.AI audio graph
-    const graphWrapper = this.inworldApp.graphWithAudioInput;
-
-    // Start graph execution in the background - it will consume from the stream
-    connection.currentAudioGraphExecution =
-      this.graphExecutor.executeAudioGraph({
-        sessionId: this.sessionKey,
-        workspaceId: connection.workspaceId,
-        apiKey: connection.apiKey,
-        input: audioStreamInput,
-        graphWrapper,
-        multimodalStreamManager: connection.multimodalStreamManager,
-      }).catch((error) => {
-        logger.error({ err: error, sessionId: this.sessionKey }, `${context} - Error in audio graph execution`);
-        // Clean up on error
-        if (connection.multimodalStreamManager) {
-          connection.multimodalStreamManager.end();
-          connection.multimodalStreamManager = undefined;
-        }
-        connection.currentAudioGraphExecution = undefined;
-        // Send error to websocket
-        this.send(
-          RealtimeEventFactory.error({
-            type: 'server_error',
-            message: error instanceof Error ? error.message : 'Error in audio graph execution',
-          }),
-        );
-      });
-  }
-
-  /**
-   * Handle input_audio_buffer.append event
-   * Stream audio directly to Inworld SDK 0.8 audio graph
-   */
-  async handleInputAudioBufferAppend(
-    event: RT.InputAudioBufferAppendEvent,
-  ): Promise<void> {
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (!connection) {
-      logger.error({ sessionId: this.sessionKey }, 'Audio - No connection found');
-      return;
-    }
-
-    // Decode base64 audio (PCM16 at 24kHz from OpenAI)
-    const audioBuffer = Buffer.from(event.audio, 'base64');
-    const int16Array = new Int16Array(
-      audioBuffer.buffer,
-      audioBuffer.byteOffset,
-      audioBuffer.length / 2,
-    );
-
-    // Convert PCM16 Int16 to Float32 for Inworld graph (normalize to -1.0 to 1.0)
-    const float32Array = new Float32Array(int16Array.length);
-    for (let i = 0; i < int16Array.length; i++) {
-      float32Array[i] = int16Array[i] / 32768.0;
-    }
-
-    // Downsample from 24kHz to 16kHz (2:3 ratio)
-    // For every 3 samples at 24kHz, we output 2 samples at 16kHz
-    const targetLength = Math.floor(float32Array.length * 2 / 3);
-    const resampled = new Float32Array(targetLength);
-    
-    for (let i = 0; i < targetLength; i++) {
-      const sourceIndex = i * 1.5; // 24kHz/16kHz = 1.5
-      const index0 = Math.floor(sourceIndex);
-      const index1 = Math.min(index0 + 1, float32Array.length - 1);
-      const frac = sourceIndex - index0;
-      
-      // Linear interpolation
-      resampled[i] = float32Array[index0] * (1 - frac) + float32Array[index1] * frac;
-    }
-
-    // Convert to number array for MultimodalStreamManager
-    const audioData = Array.from(resampled);
-
-    // Ensure the audio graph execution is running
-    this.ensureAudioGraphExecution(connection, 'Audio');
-
-    // Push the audio chunk to the stream (already resampled to 16kHz)
-    connection.multimodalStreamManager!.pushAudio({
-      data: audioData,
-      sampleRate: INPUT_SAMPLE_RATE, // 16kHz for Inworld graph
-    });
-  }
-
-  /**
-   * Handle input_audio_buffer.commit event
-   * End the audio stream and wait for graph to complete
-   */
-  async handleInputAudioBufferCommit(
-    event: RT.InputAudioBufferCommitEvent,
-  ): Promise<void> {
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (!connection) {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          message: 'No connection found',
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    if (!connection.multimodalStreamManager) {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          message: 'No active audio stream',
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    logger.info({ sessionId: this.sessionKey }, `Commit - Manual commit requested - ending audio stream [${this.sessionKey}]`);
-    connection.multimodalStreamManager.end();
-
-    // Wait for the graph execution to complete
-    if (connection.currentAudioGraphExecution) {
-      await connection.currentAudioGraphExecution;
-    }
-
-    // Clear the buffer
-    this.sessionManager.getSession().inputAudioBuffer = [];
-  }
-
-  /**
-   * Handle input_audio_buffer.clear event
-   */
-  async handleInputAudioBufferClear(
-    event: RT.InputAudioBufferClearEvent,
-  ): Promise<void> {
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (connection?.multimodalStreamManager) {
-      connection.multimodalStreamManager.end();
-      connection.multimodalStreamManager = undefined;
-      connection.currentAudioGraphExecution = undefined;
-    }
-
-    this.sessionManager.getSession().inputAudioBuffer = [];
-    this.send(RealtimeEventFactory.inputAudioBufferCleared());
-  }
-
-  /**
-   * Handle text input by pushing it to the multimodal stream manager
-   * This unifies text and audio inputs through the same audio graph
-   */
-  async handleTextInput(text: string): Promise<void> {
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (!connection) {
-      logger.error({ sessionId: this.sessionKey }, 'Text Input - No connection found');
-      return;
-    }
-
-    logger.info({ sessionId: this.sessionKey, text: text.substring(0, 100) }, `Text Input - Pushing text to audio graph: "${text.substring(0, 50)}..."`);
-
-    // Ensure the audio graph execution is running
-    this.ensureAudioGraphExecution(connection, 'Text Input');
-
-    // Push the text to the stream
-    connection.multimodalStreamManager!.pushText(text);
-
-    // Don't wait for completion here - let the graph run in the background
-    // The graph will automatically create a response when it processes the text
-    // The response.create event will wait for completion if needed
-  }
-}
-
diff --git a/realtime-service/src/components/graphs/graph.ts b/realtime-service/src/components/graphs/graph.ts
deleted file mode 100644
index 704fdb9..0000000
--- a/realtime-service/src/components/graphs/graph.ts
+++ /dev/null
@@ -1,308 +0,0 @@
-import {
-  Graph,
-  GraphBuilder,
-  ProxyNode,
-  RemoteLLMChatNode,
-  RemoteTTSNode,
-  FakeTTSComponent,
-  TextAggregatorNode,
-  TextChunkingNode, FakeRemoteLLMComponent,
-  RemoteLLMChatRoutingNode  // TODO: Create GraphTypes.LLMChatRoutingRequest and use remoteLLMChatRoutingNode instead
-} from '@inworld/runtime/graph';
-import * as os from 'os';
-import * as path from 'path';
-import logger from '../../logger';
-
-import {
-  INPUT_SAMPLE_RATE,
-  TTS_SAMPLE_RATE,
-} from '../../config';
-import { CreateGraphPropsInterface, State, TextInput } from '../../types/index';
-import { getAssemblyAISettingsForEagerness } from '../../types/settings';
-import { AssemblyAISTTWebSocketNode } from './nodes/assembly_ai_stt_ws_node';
-import { DialogPromptBuilderNode } from './nodes/dialog_prompt_builder_node';
-import { InteractionQueueNode } from './nodes/interaction_queue_node';
-import { StateUpdateNode } from './nodes/state_update_node';
-import { TextInputNode } from './nodes/text_input_node';
-import { TranscriptExtractorNode } from './nodes/transcript_extractor_node';
-import { TTSRequestBuilderNode } from './nodes/tts_request_builder_node';
-
-export class InworldGraphWrapper {
-  graph: Graph;
-  assemblyAINode: AssemblyAISTTWebSocketNode;
-
-  private constructor({ graph, assemblyAINode }: { graph: Graph; assemblyAINode: AssemblyAISTTWebSocketNode }) {
-    this.graph = graph;
-    this.assemblyAINode = assemblyAINode;
-  }
-
-  async destroy() {
-    await this.graph.stop();
-  }
-
-  static async create(props: CreateGraphPropsInterface) {
-    const {
-      llmModelName,
-      llmProvider,
-      voiceId,
-      connections,
-      ttsModelId,
-      useMocks = false,
-    } = props;
-
-    const postfix = `-multimodal`;
-
-    const dialogPromptBuilderNode = new DialogPromptBuilderNode({
-      id: `dialog-prompt-builder-node${postfix}`,
-    });
-
-    const textInputNode = new TextInputNode({
-      id: `text-input-node${postfix}`,
-      connections,
-      reportToClient: true,
-    });
-
-    const llmNode = new RemoteLLMChatNode({
-      id: `llm-node${postfix}`,
-      provider: llmProvider,
-      modelName: llmModelName,
-      stream: true,
-      textGenerationConfig: {
-        maxNewTokens: 320
-      },
-      reportToClient: true,
-      ...(useMocks && {
-        llmComponent: new FakeRemoteLLMComponent({
-          id: `llm-component${postfix}`,
-          modelName: llmModelName,
-          provider: llmProvider,
-        }),
-      }),
-    });
-
-    const textChunkingNode = new TextChunkingNode({
-      id: `text-chunking-node${postfix}`,
-    });
-
-    const textAggregatorNode = new TextAggregatorNode({
-      id: `text-aggregator-node${postfix}`,
-    });
-
-    const stateUpdateNode = new StateUpdateNode({
-      id: `state-update-node${postfix}`,
-      connections,
-      reportToClient: true,
-    });
-
-    const ttsRequestBuilderNode = new TTSRequestBuilderNode({
-      id: `tts-request-builder-node${postfix}`,
-      connections,
-      defaultVoiceId: voiceId,
-      reportToClient: false,
-    });
-
-    const ttsNode = new RemoteTTSNode({
-      id: `tts-node${postfix}`,
-      speakerId: voiceId,
-      modelId: ttsModelId,
-      sampleRate: TTS_SAMPLE_RATE,
-      temperature: 1.1,
-      speakingRate: 1,
-      reportToClient: true,
-      ...(useMocks && {
-        ttsComponent: new FakeTTSComponent({
-          id: `tts-component-${postfix}`,
-          loadTestConfig: {
-            firstChunkDelay: 200,
-            sampleRate: 48000,
-            errorProbability: 0.0,
-            chunksPerRequest: 20,
-            interChunkDelay: 100,
-            collectMetrics: true,
-          },
-        }),
-      }),
-    });
-
-    // A second branch that only executes text chunking - we will not execute TTS when output_modality doesn't contain audio
-    const dialogPromptBuilderNodeTextOnly = new DialogPromptBuilderNode({
-      id: `dialog-prompt-builder-node-text-only${postfix}`,
-    });
-
-    const textChunkingNodeTextOnly = new TextChunkingNode({
-      id: `text-chunking-node-text-only${postfix}`,
-      reportToClient: true,
-    });
-
-    const llmNodeTextOnly = new RemoteLLMChatNode({
-      id: `llm-node-text-only${postfix}`,
-      provider: llmProvider,
-      modelName: llmModelName,
-      stream: true,
-      textGenerationConfig: { maxNewTokens: 320 },
-      reportToClient: true,
-      ...(useMocks && {
-        llmComponent: new FakeRemoteLLMComponent({
-          id: `llm-component-text-only${postfix}`,
-          modelName: llmModelName,
-          provider: llmProvider,
-        }),
-      }),
-    });
-
-    const textAggregatorNodeTextOnly = new TextAggregatorNode({
-      id: `text-aggregator-node-text-only${postfix}`,
-    });
-
-    const stateUpdateNodeTextOnly = new StateUpdateNode({
-      id: `state-update-node-text-only${postfix}`,
-      connections,
-      reportToClient: true,
-    });
-    // End of the text only branch
-
-    const graphName = `voice-agent${postfix}`;
-    const graphBuilder = new GraphBuilder({
-      id: graphName,
-      enableRemoteConfig: false,
-    });
-
-    graphBuilder
-      .addNode(textInputNode)
-      .addNode(dialogPromptBuilderNode)
-      .addNode(llmNode)
-      .addNode(textChunkingNode)
-      .addNode(textAggregatorNode)
-      .addNode(ttsRequestBuilderNode)
-      .addNode(ttsNode)
-      .addNode(stateUpdateNode)
-      .addEdge(textInputNode, dialogPromptBuilderNode, {
-        condition: async (input: State) => {
-          return input?.output_modalities.includes("audio")
-        },
-      })
-      .addEdge(dialogPromptBuilderNode, llmNode)
-      .addEdge(llmNode, textChunkingNode)
-      .addEdge(textInputNode, ttsRequestBuilderNode, {
-        condition: async (input: State) => {
-          return input?.output_modalities.includes("audio")
-        },
-      })
-      .addEdge(textChunkingNode, ttsRequestBuilderNode)
-      .addEdge(ttsRequestBuilderNode, ttsNode)
-      .addEdge(llmNode, textAggregatorNode)
-      .addEdge(textAggregatorNode, stateUpdateNode)
-      // Text-only outputs nodes/edges
-      .addNode(dialogPromptBuilderNodeTextOnly)
-      .addNode(textChunkingNodeTextOnly)
-      .addNode(llmNodeTextOnly)
-      .addNode(textAggregatorNodeTextOnly)
-      .addNode(stateUpdateNodeTextOnly)
-      .addEdge(textInputNode, dialogPromptBuilderNodeTextOnly, {
-        condition: async (input: State) => {
-          return !input?.output_modalities.includes("audio") && input?.output_modalities.includes("text")
-        },
-      })
-      .addEdge(dialogPromptBuilderNodeTextOnly, llmNodeTextOnly)
-      .addEdge(llmNodeTextOnly, textChunkingNodeTextOnly)
-      .addEdge(llmNodeTextOnly, textAggregatorNodeTextOnly)
-      .addEdge(textAggregatorNodeTextOnly, stateUpdateNodeTextOnly)
-      ;
-
-
-    // Validate configuration
-    if (!props.assemblyAIApiKey) {
-      throw new Error('Assembly.AI API key is required for audio input');
-    }
-
-    logger.info('Building graph with Multimodal pipeline');
-
-    // Start node to pass the audio input to Assembly.AI STT
-    const audioInputNode = new ProxyNode();
-    const interactionQueueNode = new InteractionQueueNode({
-      id: `interaction-queue-node${postfix}`,
-      connections,
-      reportToClient: false,
-    });
-
-    // Get eagerness settings from connection state, default to 'medium'
-    const connection = connections[Object.keys(connections)[0]];
-    const eagerness = connection?.state?.eagerness || 'medium';
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness(eagerness);
-
-    logger.info({
-      eagerness,
-      profile: turnDetectionSettings.description,
-      endOfTurnConfidenceThreshold: turnDetectionSettings.endOfTurnConfidenceThreshold,
-      minEndOfTurnSilenceWhenConfident: turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
-      maxTurnSilence: turnDetectionSettings.maxTurnSilence,
-    }, `Configured eagerness: ${eagerness} (${turnDetectionSettings.description})`);
-
-    const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
-      id: `assembly-ai-stt-ws-node${postfix}`,
-      config: {
-        apiKey: props.assemblyAIApiKey!,
-        connections: connections,
-        sampleRate: INPUT_SAMPLE_RATE,
-        formatTurns: false,
-        endOfTurnConfidenceThreshold: turnDetectionSettings.endOfTurnConfidenceThreshold,
-        minEndOfTurnSilenceWhenConfident: turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
-        maxTurnSilence: turnDetectionSettings.maxTurnSilence,
-      },
-    });
-
-    const transcriptExtractorNode = new TranscriptExtractorNode({
-      id: `transcript-extractor-node${postfix}`,
-      reportToClient: true,
-    });
-
-    graphBuilder
-      .addNode(audioInputNode)
-      .addNode(assemblyAISTTNode)
-      .addNode(transcriptExtractorNode)
-      .addNode(interactionQueueNode)
-      .addEdge(audioInputNode, assemblyAISTTNode)
-      .addEdge(assemblyAISTTNode, assemblyAISTTNode, {
-        condition: async (input: any) => {
-          return input?.stream_exhausted !== true;
-        },
-        loop: true,
-        optional: true,
-      })
-      // When interaction is complete, send to transcriptExtractorNode for processing
-      .addEdge(assemblyAISTTNode, transcriptExtractorNode, {
-        condition: async (input: any) => {
-          return input?.interaction_complete === true;
-        },
-      })
-      .addEdge(transcriptExtractorNode, interactionQueueNode)
-      .addEdge(interactionQueueNode, textInputNode, {
-        condition: (input: TextInput) => {
-          logger.debug({ text: input.text?.substring(0, 100) }, `InteractionQueueNode checking condition: "${input.text?.substring(0, 50)}..."`);
-          return input.text && input.text.trim().length > 0;
-        },
-      })
-      .addEdge(stateUpdateNode, interactionQueueNode, {
-        loop: true,
-        optional: true,
-      })
-      .setStartNode(audioInputNode);
-
-    graphBuilder.setEndNode(ttsNode);
-
-    const graph = graphBuilder.build();
-    if (props.graphVisualizationEnabled) {
-      const graphPath = path.join(os.tmpdir(), `${graphName}.png`);
-      logger.info(
-        { graphPath },
-        'The Graph visualization will be saved to this path. If you see any fatal error after this message, pls disable graph visualization'
-      );
-    }
-
-    // Return wrapper with assemblyAI node reference
-    return new InworldGraphWrapper({
-      graph,
-      assemblyAINode: assemblyAISTTNode,
-    });
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts b/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
deleted file mode 100644
index 8b6a9c8..0000000
--- a/realtime-service/src/components/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ /dev/null
@@ -1,855 +0,0 @@
-import { DataStreamWithMetadata } from '@inworld/runtime';
-import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
-import WebSocket from 'ws';
-import { v4 as uuidv4 } from 'uuid';
-
-import { Connection } from '../../../types/index';
-import { getAssemblyAISettingsForEagerness } from '../../../types/settings';
-import logger from '../../../logger';
-import { formatSession, formatContext, formatError } from '../../../log-helpers';
-import { float32ToPCM16 } from '../../audio/audio_utils';
-
-/**
- * Configuration interface for AssemblyAISTTWebSocketNode
- */
-export interface AssemblyAISTTWebSocketNodeConfig {
-  /** Assembly.AI API key */
-  apiKey: string;
-  /** Connections map to access session state */
-  connections: { [sessionId: string]: Connection };
-  /** Sample rate of the audio stream in Hz */
-  sampleRate?: number;
-  /** Enable turn formatting from Assembly.AI */
-  formatTurns?: boolean;
-  /** End of turn confidence threshold (0-1) */
-  endOfTurnConfidenceThreshold?: number;
-  /** Minimum silence duration when confident (in milliseconds) */
-  minEndOfTurnSilenceWhenConfident?: number;
-  /** Maximum turn silence (in milliseconds) */
-  maxTurnSilence?: number;
-  /** Language code (e.g., 'en', 'es') */
-  language?: string;
-  /** Keywords/keyterms to boost recognition */
-  keytermsPrompt?: string[];
-}
-
-/**
- * Manages a persistent WebSocket connection to Assembly.AI for a single session.
- * Encapsulates connection lifecycle, inactivity timeouts, and message sending.
- */
-class AssemblyAISession {
-  private ws: WebSocket | null = null;
-  private wsReady: boolean = false;
-  private wsConnectionPromise: Promise<void> | null = null;
-
-  public assemblySessionId: string = '';
-  public sessionExpiresAt: number = 0;
-  public shouldStopProcessing: boolean = false;
-
-  private inactivityTimeout: NodeJS.Timeout | null = null;
-  private lastActivityTime: number = Date.now();
-  private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
-
-  constructor(
-    public readonly sessionId: string,
-    private apiKey: string,
-    private url: string,
-    private onCleanup: (sessionId: string) => void
-  ) {}
-
-  /**
-   * Ensure WebSocket connection is ready, reconnecting if needed
-   */
-  public async ensureConnection(): Promise<void> {
-    // Check if connection is expired
-    const now = Math.floor(Date.now() / 1000);
-    const isExpired = this.sessionExpiresAt > 0 && now >= this.sessionExpiresAt;
-
-    if (
-      !this.ws ||
-      !this.wsReady ||
-      this.ws.readyState !== WebSocket.OPEN ||
-      isExpired
-    ) {
-      if (isExpired) {
-        logger.info({ sessionId: this.sessionId }, 'AssemblyAI session expired, reconnecting');
-      } else if (this.ws) {
-        logger.info({ sessionId: this.sessionId, readyState: this.ws.readyState }, `AssemblyAI connection not ready [state:${this.ws.readyState}], reconnecting`);
-      } else {
-        logger.info({ sessionId: this.sessionId }, 'AssemblyAI connecting');
-      }
-
-      // Close existing connection if any
-      this.closeWebSocket();
-
-      // Start new connection
-      this.initializeWebSocket();
-    }
-
-    if (this.wsConnectionPromise) {
-      await this.wsConnectionPromise;
-    }
-
-    // Reset flags
-    this.shouldStopProcessing = false;
-    this.resetInactivityTimer();
-  }
-
-  /**
-   * Initialize the WebSocket connection
-   */
-  private initializeWebSocket(): void {
-    logger.info({ sessionId: this.sessionId }, 'AssemblyAI initializing WebSocket');
-
-    this.wsConnectionPromise = new Promise<void>((resolve, reject) => {
-      logger.info({ sessionId: this.sessionId, url: this.url }, 'AssemblyAI WS STT - Connecting');
-
-      this.ws = new WebSocket(this.url, {
-        headers: { Authorization: this.apiKey },
-      });
-
-      this.ws.on('open', () => {
-        logger.info({ sessionId: this.sessionId }, `AssemblyAI WebSocket opened ${formatSession(this.sessionId)}`);
-        this.wsReady = true;
-        resolve();
-      });
-
-      // Permanent message handler for session metadata
-      this.ws.on('message', (data: WebSocket.Data) => {
-        try {
-          const message = JSON.parse(data.toString());
-          if (message.type === 'Begin') {
-            this.assemblySessionId = message.id || message.session_id || '';
-            this.sessionExpiresAt = message.expires_at || 0;
-            logger.info({
-              sessionId: this.sessionId,
-              assemblySessionId: this.assemblySessionId,
-              expiresAt: this.sessionExpiresAt ? new Date(this.sessionExpiresAt * 1000).toISOString() : 'unknown',
-            }, `AssemblyAI session began ${formatSession(this.sessionId)} [assembly:${this.assemblySessionId}]`);
-          }
-        } catch (error) {
-          // Ignore parsing errors here, they might be handled by other listeners
-        }
-      });
-
-      this.ws.on('error', (error: Error) => {
-        logger.error({ err: error, sessionId: this.sessionId }, 'AssemblyAI WebSocket error');
-        this.wsReady = false;
-        reject(error);
-      });
-
-      this.ws.on('close', (code: number, reason: Buffer) => {
-        logger.info({
-          sessionId: this.sessionId,
-          code,
-          reason: reason.toString(),
-        }, `AssemblyAI WebSocket closed ${formatSession(this.sessionId)} [code:${code}] [reason:${reason.toString()}]`);
-        this.wsReady = false;
-      });
-    });
-  }
-
-  /**
-   * Add a message listener
-   */
-  public onMessage(listener: (data: WebSocket.Data) => void): void {
-    if (this.ws) {
-      this.ws.on('message', listener);
-    }
-  }
-
-  /**
-   * Remove a message listener
-   */
-  public offMessage(listener: (data: WebSocket.Data) => void): void {
-    if (this.ws) {
-      this.ws.off('message', listener);
-    }
-  }
-
-  /**
-   * Send audio data
-   */
-  public sendAudio(pcm16Data: Int16Array): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(Buffer.from(pcm16Data.buffer));
-      this.resetInactivityTimer();
-    } else {
-      logger.warn({ sessionId: this.sessionId }, 'AssemblyAI WebSocket not open, skipping audio chunk');
-    }
-  }
-
-  /**
-   * Update turn detection configuration on the active WebSocket connection
-   */
-  public updateConfiguration(config: {
-    endOfTurnConfidenceThreshold?: number;
-    minEndOfTurnSilenceWhenConfident?: number;
-    maxTurnSilence?: number;
-  }): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      const updateMessage: any = {
-        type: 'UpdateConfiguration',
-      };
-
-      if (config.endOfTurnConfidenceThreshold !== undefined) {
-        updateMessage.end_of_turn_confidence_threshold = config.endOfTurnConfidenceThreshold;
-      }
-      if (config.minEndOfTurnSilenceWhenConfident !== undefined) {
-        updateMessage.min_end_of_turn_silence_when_confident = config.minEndOfTurnSilenceWhenConfident;
-      }
-      if (config.maxTurnSilence !== undefined) {
-        updateMessage.max_turn_silence = config.maxTurnSilence;
-      }
-
-      this.ws.send(JSON.stringify(updateMessage));
-      logger.info({ sessionId: this.sessionId, config: updateMessage }, `AssemblyAI configuration updated ${formatSession(this.sessionId)}`);
-    } else {
-      logger.warn({ sessionId: this.sessionId }, 'AssemblyAI cannot update config: WebSocket not open');
-    }
-  }
-
-
-  /**
-   * Reset the inactivity timer
-   */
-  private resetInactivityTimer(): void {
-    if (this.inactivityTimeout) {
-      clearTimeout(this.inactivityTimeout);
-    }
-
-    this.lastActivityTime = Date.now();
-    this.inactivityTimeout = setTimeout(() => {
-      this.closeDueToInactivity();
-    }, this.INACTIVITY_TIMEOUT_MS);
-  }
-
-  /**
-   * Close connection due to inactivity
-   */
-  private closeDueToInactivity(): void {
-    const inactiveFor = Date.now() - this.lastActivityTime;
-    logger.info({ sessionId: this.sessionId, inactiveFor }, `AssemblyAI closing due to inactivity ${formatSession(this.sessionId)} [inactive:${inactiveFor}ms]`);
-
-    this.shouldStopProcessing = true;
-    this.close();
-    this.onCleanup(this.sessionId);
-  }
-
-  /**
-   * Close the WebSocket connection
-   */
-  private closeWebSocket(): void {
-    if (this.ws) {
-      try {
-        // Remove all listeners to prevent leaks
-        this.ws.removeAllListeners();
-        if (this.ws.readyState === WebSocket.OPEN) {
-          this.ws.close();
-        }
-      } catch (e) {
-        logger.warn({ err: e, sessionId: this.sessionId }, 'AssemblyAI error closing socket');
-      }
-      this.ws = null;
-      this.wsReady = false;
-    }
-  }
-
-  /**
-   * Gracefully close the session
-   */
-  public async close(): Promise<void> {
-    if (this.inactivityTimeout) {
-      clearTimeout(this.inactivityTimeout);
-    }
-
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      try {
-        this.ws.send(JSON.stringify({ type: 'Terminate' }));
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      } catch (e) {
-        // Ignore error on send
-      }
-    }
-
-    this.closeWebSocket();
-  }
-}
-
-/**
- * AssemblyAISTTWebSocketNode processes continuous multimodal streams (audio and/or text) using Assembly.AI's
- * streaming Speech-to-Text service via direct WebSocket connection.
- *
- * This node:
- * - Receives MultimodalContent stream (audio and/or text)
- * - For audio: extracts audio from MultimodalContent and feeds to Assembly.AI streaming transcriber
- * - For text: skips processing (text input should bypass STT)
- * - Connects directly to Assembly.AI WebSocket endpoint
- * - Detects turn endings automatically using Assembly.AI's turn detection
- * - Returns DataStreamWithMetadata with transcribed text when a turn completes
- */
-export class AssemblyAISTTWebSocketNode extends CustomNode {
-  private apiKey: string;
-  private connections: { [sessionId: string]: Connection };
-  private sampleRate: number;
-  private formatTurns: boolean;
-  private endOfTurnConfidenceThreshold: number;
-  private minEndOfTurnSilenceWhenConfident: number;
-  private maxTurnSilence: number;
-  private language: string;
-  private keytermsPrompt: string[];
-  private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
-
-  private sessions: Map<string, AssemblyAISession> = new Map();
-  private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
-  private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
-
-  constructor(props: {
-    id?: string;
-    config: AssemblyAISTTWebSocketNodeConfig;
-  }) {
-    const { config, ...nodeProps } = props;
-
-    if (!config.apiKey) {
-      throw new Error('AssemblyAISTTWebSocketNode requires an API key.');
-    }
-
-    if (!config.connections) {
-      throw new Error(
-        'AssemblyAISTTWebSocketNode requires a connections object.',
-      );
-    }
-
-    super({
-      id: nodeProps.id || 'assembly-ai-stt-ws-node',
-      executionConfig: {
-        sampleRate: config.sampleRate || 16000,
-        formatTurns: config.formatTurns !== false,
-        endOfTurnConfidenceThreshold:
-          config.endOfTurnConfidenceThreshold || 0.4,
-        minEndOfTurnSilenceWhenConfident:
-          config.minEndOfTurnSilenceWhenConfident || 400,
-        maxTurnSilence: config.maxTurnSilence || 1280,
-        language: config.language || 'en',
-      },
-    });
-
-    this.apiKey = config.apiKey;
-    this.connections = config.connections;
-    this.sampleRate = config.sampleRate || 16000;
-    this.formatTurns = config.formatTurns !== false;
-    this.endOfTurnConfidenceThreshold =
-      config.endOfTurnConfidenceThreshold || 0.4;
-    this.minEndOfTurnSilenceWhenConfident =
-      config.minEndOfTurnSilenceWhenConfident || 400;
-    this.maxTurnSilence = config.maxTurnSilence || 1280;
-    this.language = config.language || 'en';
-    this.keytermsPrompt = config.keytermsPrompt || [];
-
-    // Log the turn detection settings being used
-    logger.info({
-      endOfTurnConfidenceThreshold: this.endOfTurnConfidenceThreshold,
-      minEndOfTurnSilenceWhenConfident: this.minEndOfTurnSilenceWhenConfident,
-      maxTurnSilence: this.maxTurnSilence,
-      sampleRate: this.sampleRate,
-      formatTurns: this.formatTurns,
-      language: this.language,
-    }, `AssemblyAI configured [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.language}]`);
-  }
-
-  /**
-   * Build WebSocket URL with query parameters
-   * Dynamically uses connection.state.eagerness if available
-   */
-  private buildWebSocketUrl(sessionId?: string): string {
-    // Get current settings - check connection state for eagerness updates
-    let endOfTurnThreshold = this.endOfTurnConfidenceThreshold;
-    let minSilenceWhenConfident = this.minEndOfTurnSilenceWhenConfident;
-    let maxSilence = this.maxTurnSilence;
-
-    if (sessionId) {
-      const connection = this.connections[sessionId];
-      const eagerness = connection?.state?.eagerness;
-
-      if (eagerness) {
-        // Map eagerness to settings dynamically using shared settings function
-        const settings = getAssemblyAISettingsForEagerness(eagerness);
-        endOfTurnThreshold = settings.endOfTurnConfidenceThreshold;
-        minSilenceWhenConfident = settings.minEndOfTurnSilenceWhenConfident;
-        maxSilence = settings.maxTurnSilence;
-
-        logger.info({ sessionId, eagerness }, `AssemblyAI using eagerness settings: ${eagerness}`);
-      }
-    }
-
-    const params = new URLSearchParams({
-      sample_rate: this.sampleRate.toString(),
-      format_turns: this.formatTurns.toString(),
-      end_of_turn_confidence_threshold: endOfTurnThreshold.toString(),
-      min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
-      max_turn_silence: maxSilence.toString(),
-      language: this.language,
-    });
-
-    // Add keyterms if provided
-    if (this.keytermsPrompt.length > 0) {
-      this.keytermsPrompt.forEach((term) => {
-        params.append('keyterms_prompt', term);
-      });
-    }
-
-    const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
-
-    logger.info({
-      sessionId,
-      endOfTurnConfidenceThreshold: endOfTurnThreshold,
-      minEndOfTurnSilenceWhenConfident: minSilenceWhenConfident,
-      maxTurnSilence: maxSilence,
-    }, `AssemblyAI connecting ${formatSession(sessionId)} [threshold:${endOfTurnThreshold}] [silence:${minSilenceWhenConfident}ms]`);
-
-    return url;
-  }
-
-
-  /**
-   * Process multimodal stream (audio and/or text) and transcribe using Assembly.AI WebSocket
-   * For audio: extracts audio from MultimodalContent and sends to Assembly.AI
-   * For text: currently not handled (text input should bypass STT)
-   */
-  async process(
-    context: ProcessContext,
-    input0: AsyncIterableIterator<GraphTypes.MultimodalContent>,
-    input: DataStreamWithMetadata,
-  ): Promise<DataStreamWithMetadata> {
-    // Extract MultimodalContent stream from either input type
-    const multimodalStream =
-      input !== undefined &&
-      input !== null &&
-      input instanceof DataStreamWithMetadata
-        ? (input.toStream() as any as AsyncIterableIterator<GraphTypes.MultimodalContent>)
-        : input0;
-
-    const sessionId = context.getDatastore().get('sessionId') as string;
-    const connection = this.connections[sessionId];
-
-    // Check connection exists before accessing its properties
-    if (connection?.unloaded) {
-      throw Error(`Session unloaded for sessionId: ${sessionId}`);
-    }
-    if (!connection) {
-      throw Error(`Failed to read connection for sessionId: ${sessionId}`);
-    }
-
-    // Get iteration number from metadata, or parse from interactionId
-    const metadata = input?.getMetadata?.() || {};
-    let previousIteration = (metadata.iteration as number) || 0;
-
-    // If interactionId is empty, assign a UUID
-    if (!connection.state.interactionId || connection.state.interactionId === '') {
-      connection.state.interactionId = uuidv4();
-      logger.info({ sessionId, interactionId: connection.state.interactionId }, 'AssemblyAI assigned new UUID for empty interactionId');
-    }
-
-    const currentId = connection.state.interactionId;
-    const delimiterIndex = currentId.indexOf('#');
-
-    if (previousIteration === 0 && delimiterIndex !== -1) {
-      const iterationStr = currentId.substring(delimiterIndex + 1);
-      const parsedIteration = parseInt(iterationStr, 10);
-      if (!isNaN(parsedIteration) && /^\d+$/.test(iterationStr)) {
-        previousIteration = parsedIteration;
-      }
-    }
-
-    const iteration = previousIteration + 1;
-    const baseId =
-      delimiterIndex !== -1
-        ? currentId.substring(0, delimiterIndex)
-        : currentId;
-    const nextInteractionId = `${baseId}#${iteration}`;
-
-    logger.info({ sessionId, iteration }, `AssemblyAI starting transcription [iteration:${iteration}]`);
-
-    // State tracking
-    let transcriptText = '';
-    let turnDetected = false;
-    let speechDetected = false;
-    let audioChunkCount = 0;
-    let totalAudioSamples = 0;
-    let isStreamExhausted = false;
-    let errorOccurred = false;
-    let errorMessage = '';
-    let maxDurationReached = false;
-    // For text modality input
-    let isTextInput = false;
-    let textContent: string | undefined;
-
-    // Get or create session
-    let session = this.sessions.get(sessionId);
-    if (!session) {
-      session = new AssemblyAISession(
-        sessionId,
-        this.apiKey,
-        this.buildWebSocketUrl(sessionId), // Pass sessionId to get dynamic eagerness settings
-        (id) => this.sessions.delete(id)
-      );
-      this.sessions.set(sessionId, session);
-    }
-
-    // Promise to capture the turn result
-    let turnResolve: (value: string) => void;
-    let turnReject: (error: any) => void;
-    let turnCompleted = false;
-    const turnPromise = new Promise<string>((resolve, reject) => {
-      turnResolve = resolve;
-      turnReject = reject;
-    });
-    const turnPromiseWithState = turnPromise.then((value) => {
-      turnCompleted = true;
-      return value;
-    });
-
-    // Assembly AI Callback handler
-    const messageHandler = (data: WebSocket.Data) => {
-      try {
-        const message = JSON.parse(data.toString());
-        const msgType = message.type;
-
-        if (msgType === 'Turn') {
-          // Ignore turn events if we've already decided to stop
-          if (session?.shouldStopProcessing) {
-            return;
-          }
-
-          const transcript = message.transcript || '';
-          const utterance = message.utterance || '';
-          const isFinal = message.end_of_turn;
-
-          if (!transcript) return;
-
-          if (!isFinal) {
-            // Send partial transcript
-            const textToSend = utterance || transcript;
-            if (textToSend) {
-              this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
-
-              if (connection?.onSpeechDetected && !speechDetected) {
-                logger.info({ sessionId, iteration, interactionId: nextInteractionId }, `AssemblyAI speech detected [iteration:${iteration}]`);
-                speechDetected = true;
-                connection.onSpeechDetected(nextInteractionId);
-              }
-            }
-            return;
-          }
-
-          // Final transcript
-          logger.info({ sessionId, iteration, transcript }, `AssemblyAI turn detected ${formatSession(sessionId)} [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
-
-          transcriptText = transcript;
-          turnDetected = true;
-          if (session) session.shouldStopProcessing = true;
-          turnResolve(transcript);
-
-        } else if (msgType === 'Termination') {
-          logger.info({ sessionId, iteration }, `AssemblyAI session terminated ${formatSession(sessionId)} [iteration:${iteration}]`);
-        }
-      } catch (error) {
-        logger.error({ err: error, sessionId, iteration }, `AssemblyAI error handling message [iteration:${iteration}]`);
-      }
-    };
-
-    try {
-      // Ensure WebSocket connection is ready
-      await session.ensureConnection();
-
-      // Attach message handler
-      session.onMessage(messageHandler);
-
-      // Process multimodal content (audio chunks)
-      const audioProcessingPromise = (async () => {
-        let maxDurationTimeout: NodeJS.Timeout | null = null;
-        try {
-          logger.debug({ sessionId, iteration }, 'AssemblyAI WS STT - Starting multimodal processing loop');
-
-
-          // Safety timer: prevent infinite loops if no turn is detected
-          maxDurationTimeout = setTimeout(() => {
-            maxDurationReached = true; // Ensure maximum process() execution length doesn't exceed 40. If the player with an active mic does not speak for 60s, the node executor will error out thinking it's a zombie node
-            // We'll loop back in the graph and continue after timing out
-          }, this.MAX_TRANSCRIPTION_DURATION_MS);
-
-          while (true) {
-            if (session?.shouldStopProcessing) {
-              break;
-            }
-
-            if (maxDurationReached) {
-              if (!transcriptText) {
-                logger.warn({ sessionId, iteration }, `AssemblyAI max transcription duration reached [limit:${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`);
-                break;
-              }
-            }
-
-            const result = await multimodalStream.next();
-
-            if (result.done) {
-              logger.info({ sessionId, iteration, audioChunkCount }, `AssemblyAI multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`);
-              isStreamExhausted = true;
-              break;
-            }
-
-            if (session?.shouldStopProcessing) break;
-
-            const content = result.value as GraphTypes.MultimodalContent;
-
-            // Handle text input - immediately simulate turn detection
-            if (content.text !== undefined && content.text !== null) {
-              logger.info({ sessionId, iteration, text: content.text }, `AssemblyAI text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`);
-              isTextInput = true;
-              textContent = content.text;
-              transcriptText = content.text;
-              turnDetected = true;
-              if (session) session.shouldStopProcessing = true;
-              turnResolve(transcriptText);
-              // For text input, we immediately complete and bypass STT
-              break;
-            }
-
-            // Extract audio from MultimodalContent
-            if (content.audio === undefined || content.audio === null) {
-              continue;
-            }
-
-            const audioData = content.audio.data;
-            if (!audioData || audioData.length === 0) {
-              continue;
-            }
-
-            // Convert to Float32Array if needed
-            const float32Data = Array.isArray(audioData)
-              ? new Float32Array(audioData)
-              : audioData;
-
-            audioChunkCount++;
-            totalAudioSamples += float32Data.length;
-
-            const pcm16Data = float32ToPCM16(float32Data);
-
-            session?.sendAudio(pcm16Data);
-
-            if (audioChunkCount % 20 === 0) {
-               // Heartbeat log
-            }
-          }
-        } catch (error) {
-          logger.error({ err: error, sessionId, iteration }, `AssemblyAI error processing audio [iteration:${iteration}]`);
-          errorOccurred = true;
-          errorMessage = error instanceof Error ? error.message : String(error);
-          throw error;
-        } finally {
-          if (maxDurationTimeout) {
-            clearTimeout(maxDurationTimeout);
-          }
-        }
-      })();
-
-      const raceResult = await Promise.race([
-        turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
-        audioProcessingPromise.then(() => ({ winner: 'audio' as const })), // Audio will immediately win after the stream stops manually,
-      ]);
-
-      if (raceResult.winner === 'audio' && !turnCompleted && !maxDurationReached) { // and if audio wins, we enter this race, as turnComplete is not here yet
-        logger.info({ sessionId, iteration, timeout: this.TURN_COMPLETION_TIMEOUT_MS }, `AssemblyAI audio ended before turn [iteration:${iteration}], waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms for transcript`);
-
-        // Send 100ms of silence every 100ms to keep the connection alive/processing
-        const silenceIntervalMs = 100;
-        const silenceSamples = Math.floor((silenceIntervalMs / 1000) * this.sampleRate);
-        const silenceFrame = new Int16Array(silenceSamples);
-        const silenceTimer = setInterval(() => {
-          if (session && !session.shouldStopProcessing) {
-            session.sendAudio(silenceFrame);
-          }
-        }, silenceIntervalMs); // This is critical. Assembly AI Streaming API expects constant audio stream, or it will not emit any events.
-        // We need to continue streaming even if the user is not actively sending audio.
-
-        const timeoutPromise = new Promise<{ winner: 'timeout' }>((resolve) =>
-          setTimeout(() => resolve({ winner: 'timeout' }), this.TURN_COMPLETION_TIMEOUT_MS),
-        );
-
-        const waitResult = await Promise.race([
-          turnPromiseWithState.then(() => ({ winner: 'turn' as const })),
-          timeoutPromise,
-        ]);
-
-        // We either timed out here or received a final turn event
-        clearInterval(silenceTimer);
-
-        if (waitResult.winner === 'timeout' && !turnCompleted) {
-          logger.warn({ sessionId, iteration }, `AssemblyAI timed out waiting for turn [iteration:${iteration}]`);
-          turnReject?.(new Error('Timed out waiting for turn completion'));
-        }
-      }
-
-      // Ensure the audio processing loop fully exits before returning
-      await audioProcessingPromise.catch(() => {});
-
-      logger.info({ sessionId, iteration, transcript: transcriptText }, `AssemblyAI transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`);
-
-      // Clear interactionId on turn completion
-      if (turnDetected) {
-        logger.info({ sessionId, iteration, interactionId: nextInteractionId }, 'AssemblyAI clearing interactionId after turn completion');
-        connection.state.interactionId = '';
-      }
-
-      // Tag the stream with type for runtime
-      const taggedStream = Object.assign(multimodalStream, {
-        type: 'MultimodalContent',
-        abort: () => {
-          // No-op abort handler
-        },
-      });
-
-      return new DataStreamWithMetadata(taggedStream as any, {
-        elementType: 'MultimodalContent',
-        iteration: iteration,
-        interactionId: nextInteractionId,
-        session_id: sessionId,
-        assembly_session_id: session.assemblySessionId,
-        transcript: transcriptText,
-        turn_detected: turnDetected,
-        audio_chunk_count: audioChunkCount,
-        total_audio_samples: totalAudioSamples,
-        sample_rate: this.sampleRate,
-        stream_exhausted: isStreamExhausted,
-        interaction_complete: turnDetected && transcriptText.length > 0,
-        error_occurred: errorOccurred,
-        error_message: errorMessage,
-        endpointing_latency_ms: 0,
-        // Flags to match native graph structure
-        is_running: !isStreamExhausted,
-        is_text_input: isTextInput,
-        is_interruption: false, // Not currently handling interruptions in this node
-        text_content: textContent,
-      });
-
-    } catch (error) {
-      logger.error({ err: error, sessionId, iteration }, `AssemblyAI transcription failed [iteration:${iteration}]`);
-
-      // Tag the stream with type for runtime
-      const taggedStream = Object.assign(multimodalStream, {
-        type: 'MultimodalContent',
-        abort: () => {
-          // No-op abort handler
-        },
-      });
-
-      return new DataStreamWithMetadata(taggedStream as any, {
-        elementType: 'MultimodalContent',
-        iteration: iteration,
-        interactionId: nextInteractionId,
-        session_id: sessionId,
-        assembly_session_id: session?.assemblySessionId || '',
-        transcript: '',
-        turn_detected: false,
-        audio_chunk_count: audioChunkCount,
-        total_audio_samples: totalAudioSamples,
-        sample_rate: this.sampleRate,
-        stream_exhausted: isStreamExhausted,
-        interaction_complete: false,
-        error_occurred: true,
-        error_message: error instanceof Error ? error.message : String(error),
-        endpointing_latency_ms: 0,
-        // Flags to match native graph structure
-        is_running: !isStreamExhausted,
-        is_text_input: isTextInput,
-        is_interruption: false, // Not currently handling interruptions in this node
-        text_content: textContent,
-      });
-    }
-    finally {
-      // Clean up message handler after execution ends
-      if (session) {
-        session.offMessage(messageHandler);
-      }
-    }
-  }
-
-  /**
-   * Send partial transcript update to the client for real-time feedback
-   */
-  private sendPartialTranscript(
-    sessionId: string,
-    interactionId: string,
-    text: string,
-  ): void {
-    const connection = this.connections[sessionId];
-    if (!connection || !connection.ws) {
-      return;
-    }
-
-    try {
-      if (connection.onPartialTranscript) {
-        connection.onPartialTranscript(text, interactionId);
-      }
-    } catch (error) {
-      logger.error({ err: error, sessionId }, 'AssemblyAI error sending partial transcript');
-    }
-  }
-
-  /**
-   * Update turn detection configuration for a specific session
-   */
-  updateTurnDetectionSettings(
-    sessionId: string,
-    settings: {
-      endOfTurnConfidenceThreshold: number;
-      minEndOfTurnSilenceWhenConfident: number;
-      maxTurnSilence: number;
-    }
-  ): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      logger.warn({ sessionId }, 'AssemblyAI cannot update settings: no active session');
-      return;
-    }
-
-    // Update the node's stored settings
-    this.endOfTurnConfidenceThreshold = settings.endOfTurnConfidenceThreshold;
-    this.minEndOfTurnSilenceWhenConfident = settings.minEndOfTurnSilenceWhenConfident;
-    this.maxTurnSilence = settings.maxTurnSilence;
-
-    logger.info({ sessionId, settings }, 'AssemblyAI updating turn detection');
-
-    // Send UpdateConfiguration message to active AssemblyAI WebSocket
-    session.updateConfiguration(settings);
-  }
-
-  /**
-   * Close a specific session by sessionId
-   */
-  async closeSession(sessionId: string): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      logger.info(`[AssemblyAI WS STT] Closing session: ${sessionId}`);
-      await session.close();
-      this.sessions.delete(sessionId);
-      logger.info(`[AssemblyAI WS STT] Session ${sessionId} closed and removed`);
-    }
-  }
-
-  /**
-   * Clean up resources
-   */
-  async destroy(): Promise<void> {
-    logger.info({ sessionCount: this.sessions.size }, `AssemblyAI destroying node: closing ${this.sessions.size} WebSocket connections`);
-
-    const promises: Promise<void>[] = [];
-    for (const session of this.sessions.values()) {
-        promises.push(session.close());
-    }
-
-    await Promise.all(promises);
-    this.sessions.clear();
-    logger.info('AssemblyAI all sessions cleaned up');
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts b/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
deleted file mode 100644
index 28030b1..0000000
--- a/realtime-service/src/components/graphs/nodes/dialog_prompt_builder_node.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-
-import { State } from '../../../types/index';
-
-/**
- * DialogPromptBuilderNode builds a LLM chat request from the state.
- *
- * This node:
- * - Receives the current conversation state
- * - Converts state messages to LLM message format
- * - Returns a formatted LLMChatRequest for the LLM node
- */
-export class DialogPromptBuilderNode extends CustomNode {
-  process(_context: ProcessContext, state: State): GraphTypes.LLMChatRequest {
-    try {
-      logger.debug({ messageCount: state.messages?.length }, `DialogPromptBuilderNode start: ${state.messages?.length || 0} messages`);
-
-      // Convert state messages to LLMMessageInterface format
-      // Filter out messages with empty content
-      const conversationMessages = state.messages
-        .filter((msg) => {
-          if (!msg) {
-            logger.warn('DialogPromptBuilderNode - Found undefined message in state');
-            return false;
-          }
-          // Filter out messages with empty content
-          if (!msg.content || msg.content.trim() === '') {
-            logger.debug({ messageId: msg.id }, 'DialogPromptBuilderNode - Filtering out empty message');
-            return false;
-          }
-          return true;
-        })
-        .map((msg) => ({
-          role: msg.role,
-          content: msg.content,
-        }));
-
-      const request: any = {
-        messages: conversationMessages,
-      };
-
-      if (state.tools && Array.isArray(state.tools) && state.tools.length > 0) {
-        logger.debug({ toolCount: state.tools.length }, `DialogPromptBuilderNode processing ${state.tools.length} tools`);
-
-        // Transform OpenAI Realtime API format to Inworld SDK format
-        // OpenAI Realtime API: { type: 'function', name, description, parameters }
-        // Inworld SDK: { name, description, properties }
-        // The key difference: 'parameters' -> 'properties' (which is now a stringified JSON)
-        request.tools = state.tools
-          .filter((t: any) => t != null && typeof t === 'object')
-          .map((tool: any) => {
-            if (tool.type === 'function' && tool.name) {
-              return {
-                name: tool.name,
-                description: tool.description,
-                properties: JSON.stringify(tool.parameters || {}),
-              };
-            }
-            // If already in Inworld format or unknown, pass through
-            return tool;
-          });
-
-        logger.debug({ toolCount: request.tools.length }, `DialogPromptBuilderNode converted ${request.tools.length} tools to Inworld format`);
-
-        // Handle toolChoice - ensure it's in the right format
-        if (state.toolChoice) {
-          if (typeof state.toolChoice === 'string') {
-            request.toolChoice = { type: state.toolChoice };
-          } else {
-            request.toolChoice = state.toolChoice;
-          }
-        } else {
-          request.toolChoice = { type: 'auto' };
-        }
-
-        logger.debug({ toolChoice: request.toolChoice }, `DialogPromptBuilderNode tool choice: ${request.toolChoice}`);
-      }
-
-      logger.debug({ messageCount: conversationMessages.length }, `DialogPromptBuilderNode final request: ${conversationMessages.length} messages`);
-      return new GraphTypes.LLMChatRequest(request);
-    } catch (error) {
-      logger.error({ err: error }, 'DialogPromptBuilderNode fatal error');
-      throw error;
-    }
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts b/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
deleted file mode 100644
index 635d73e..0000000
--- a/realtime-service/src/components/graphs/nodes/interaction_queue_node.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-import { formatSession, formatContext } from '../../../log-helpers';
-
-import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../../types/index';
-
-/**
- * InteractionQueueNode manages the queue of user interactions.
- *
- * This node:
- * - Receives interaction info from STT processing
- * - Manages a queue of interactions to ensure sequential processing
- * - Prevents race conditions when multiple interactions arrive
- * - Returns TextInput when ready to process, or empty when waiting
- *
- * Queue states tracked in datastore:
- * - 'q{id}': Queued interactions waiting to be processed
- * - 'r{id}': Running interactions currently being processed
- * - 'c{id}': Completed interactions
- */
-export class InteractionQueueNode extends CustomNode {
-  private connections: ConnectionsMap;
-
-  constructor(props?: {
-    id?: string;
-    connections?: ConnectionsMap;
-    reportToClient?: boolean;
-  }) {
-    super({
-      id: props?.id || 'interaction-queue-node',
-      reportToClient: props?.reportToClient,
-    });
-    this.connections = props?.connections || {};
-  }
-
-  process(
-    context: ProcessContext,
-    interactionInfo: InteractionInfo,
-    state: State,
-  ): TextInput {
-    const sessionId = interactionInfo.sessionId;
-    logger.debug({ sessionId, interactionId: interactionInfo.interactionId }, 'InteractionQueueNode processing');
-    
-    // Get current voiceId from connection state (in case it was updated via session.update)
-    const connection = this.connections[sessionId];
-    const currentVoiceId = connection?.state?.voiceId || state?.voiceId;
-
-    // ====================================================================
-    // STEP 1-3: Store text and analyze queue state
-    // ====================================================================
-    const dataStore = context.getDatastore();
-    const QUEUED_PREFIX = 'q';
-    const RUNNING_PREFIX = 'r';
-    const COMPLETED_PREFIX = 'c';
-
-    // Register interaction in the queue
-    if (!dataStore.has(QUEUED_PREFIX + interactionInfo.interactionId)) {
-      // Store queued interaction
-      dataStore.add(
-        QUEUED_PREFIX + interactionInfo.interactionId,
-        interactionInfo.text,
-      );
-      logger.info({ sessionId, interactionId: interactionInfo.interactionId }, 'InteractionQueue - New interaction queued');
-    }
-
-    // Get all keys and categorize them
-    const allKeys = dataStore.keys();
-    const queuedIds: string[] = [];
-    let completedCount = 0;
-    let runningCount = 0;
-
-    for (const key of allKeys) {
-      if (key.startsWith(QUEUED_PREFIX)) {
-        const idStr = key.substring(QUEUED_PREFIX.length);
-        queuedIds.push(idStr);
-      } else if (key.startsWith(COMPLETED_PREFIX)) {
-        completedCount++;
-      } else if (key.startsWith(RUNNING_PREFIX)) {
-        runningCount++;
-      }
-    }
-
-    // Sort queued IDs - extract iteration number for sorting
-    queuedIds.sort((a, b) => {
-      const getIteration = (id: string): number => {
-        const hashIndex = id.indexOf('#');
-        if (hashIndex === -1) return 0;
-        const iter = parseInt(id.substring(hashIndex + 1), 10);
-        return isNaN(iter) ? 0 : iter;
-      };
-      return getIteration(a) - getIteration(b);
-    });
-
-    logger.debug({
-      sessionId,
-      queuedCount: queuedIds.length,
-      completedCount,
-      runningCount,
-    }, 'InteractionQueue - State');
-
-    // ====================================================================
-    // STEP 4: Decide if we should start processing the next interaction
-    // ====================================================================
-    if (queuedIds.length === 0) {
-      // No interactions to process yet
-      logger.debug({ sessionId }, 'InteractionQueue - No interactions to process yet');
-      return {
-        text: '',
-        sessionId: sessionId,
-        interactionId: '',
-        voiceId: currentVoiceId,
-      } as TextInput;
-    }
-
-    if (queuedIds.length === completedCount) {
-      // All interactions have been processed
-      logger.debug({ sessionId }, 'InteractionQueue - All interactions completed');
-      return {
-        text: '',
-        sessionId: sessionId,
-        interactionId: '',
-        voiceId: currentVoiceId,
-      } as TextInput;
-    }
-
-    // There are unprocessed interactions
-    if (runningCount === completedCount) {
-      // No interaction is currently running, start the next one
-      const nextId = queuedIds[completedCount];
-      const runningKey = RUNNING_PREFIX + nextId;
-
-      // NOTE: We do NOT skip interactions marked as "interrupted"
-      // The "isInterrupted" flag means "this interaction caused an interruption of a previous response"
-      // But the user's speech is still a valid request that should be processed!
-      // All user speech should result in a response.
-
-      // Try to mark as running (prevents race conditions)
-      if (dataStore.has(runningKey) || !dataStore.add(runningKey, '')) {
-        logger.debug({ sessionId, interactionId: nextId }, 'InteractionQueue - Interaction already started');
-        return {
-          text: '',
-          sessionId: sessionId,
-          interactionId: '',
-          voiceId: currentVoiceId,
-        } as TextInput;
-      }
-
-      const queuedText = dataStore.get(QUEUED_PREFIX + nextId) as string;
-      if (!queuedText) {
-        logger.error({ sessionId, interactionId: nextId }, 'InteractionQueue - Failed to retrieve text');
-        return {
-          text: '',
-          sessionId: sessionId,
-          interactionId: '',
-          voiceId: currentVoiceId,
-        } as TextInput;
-      }
-
-      logger.info({ sessionId, interactionId: nextId, text: queuedText.substring(0, 100) }, `InteractionQueue - Starting LLM processing: "${queuedText.substring(0, 50)}..."`);
-
-      return {
-        text: queuedText,
-        sessionId: sessionId,
-        interactionId: nextId,
-        voiceId: currentVoiceId,
-      } as TextInput;
-    } else {
-      // An interaction is currently running, wait for it to complete
-      logger.debug({ sessionId, waitingForInteraction: queuedIds[completedCount] }, `InteractionQueue - Waiting for interaction [waiting for:${queuedIds[completedCount]}]`);
-      return {
-        text: '',
-        sessionId: sessionId,
-        interactionId: '',
-        voiceId: currentVoiceId,
-      } as TextInput;
-    }
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/state_update_node.ts b/realtime-service/src/components/graphs/nodes/state_update_node.ts
deleted file mode 100644
index 7f31c82..0000000
--- a/realtime-service/src/components/graphs/nodes/state_update_node.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-import { formatSession, formatContext } from '../../../log-helpers';
-
-import { ConnectionsMap, State } from '../../../types/index';
-
-/**
- * StateUpdateNode updates the state with the LLM's response.
- *
- * This node:
- * - Receives the LLM output text
- * - Updates the connection state with the assistant message
- * - Marks the interaction as completed in the datastore
- * - Returns the updated state
- */
-export class StateUpdateNode extends CustomNode {
-  private connections: ConnectionsMap;
-
-  constructor(props: {
-    id: string;
-    connections: ConnectionsMap;
-    reportToClient?: boolean;
-  }) {
-    super({
-      id: props.id,
-      reportToClient: props.reportToClient,
-    });
-    this.connections = props.connections;
-  }
-
-  process(context: ProcessContext, llmOutput: string): State {
-    const sessionId = context.getDatastore().get('sessionId') as string;
-    logger.debug({ sessionId, llmOutputLength: llmOutput?.length }, `StateUpdateNode processing [length:${llmOutput?.length || 0}]`);
-
-    // Get sessionId from dataStore (constant for graph execution)
-
-    const connection = this.connections[sessionId];
-    if (connection?.unloaded) {
-      throw Error(`Session unloaded for sessionId:${sessionId}`);
-    }
-    if (!connection) {
-      throw Error(`Failed to read connection for sessionId:${sessionId}`);
-    }
-
-    // Only add assistant message if there's actual content
-    // When LLM returns tool calls only, llmOutput is empty string
-    if (llmOutput && llmOutput.trim().length > 0) {
-      logger.debug({ sessionId, content: llmOutput.substring(0, 100) }, `StateUpdateNode adding assistant message: "${llmOutput.substring(0, 50)}..."`);
-      connection.state.messages.push({
-        role: 'assistant',
-        content: llmOutput,
-        id: connection.state.interactionId,
-      });
-    } else {
-      logger.debug({ sessionId }, 'StateUpdateNode skipping empty message (likely tool call only)');
-    }
-
-    const dataStore = context.getDatastore();
-    dataStore.add('c' + connection.state.interactionId, '');
-    logger.info({
-      sessionId,
-      interactionId: connection.state.interactionId,
-    }, `StateUpdateNode marking interaction completed ${formatContext(sessionId, undefined, connection.state.interactionId)}`);
-
-    return connection.state;
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/text_input_node.ts b/realtime-service/src/components/graphs/nodes/text_input_node.ts
deleted file mode 100644
index 311a7d0..0000000
--- a/realtime-service/src/components/graphs/nodes/text_input_node.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-import { formatSession } from '../../../log-helpers';
-
-import { ConnectionsMap, State, TextInput } from '../../../types/index';
-import { TOOL_CALL_CONTINUATION_MARKER } from '../realtime_graph_executor';
-
-/**
- * TextInputNode updates the state with the user's input this turn.
- *
- * This node:
- * - Receives user text input with interaction and session IDs
- * - Updates the connection state with the user message
- * - Returns the updated state for downstream processing
- * 
- * Special handling for tool call continuation:
- * - When text is TOOL_CALL_CONTINUATION_MARKER, this is a continuation after a tool call
- * - In this case, we DON'T add a new user message (tool result is already in messages)
- * - We just return the current state to trigger the LLM with existing conversation
- */
-export class TextInputNode extends CustomNode {
-  private connections: ConnectionsMap;
-
-  constructor(props: {
-    id: string;
-    connections: ConnectionsMap;
-    reportToClient?: boolean;
-  }) {
-    super({
-      id: props.id,
-      reportToClient: props.reportToClient,
-    });
-    this.connections = props.connections;
-  }
-
-  process(context: ProcessContext, input: TextInput): State {
-    logger.debug({ sessionId: input.sessionId, text: input.text?.substring(0, 100) }, `TextInputNode processing: "${input.text?.substring(0, 50)}..."`);
-
-    const { text, interactionId, sessionId } = input;
-
-    const connection = this.connections[sessionId];
-    if (connection?.unloaded) {
-      throw Error(`Session unloaded for sessionId:${sessionId}`);
-    }
-    if (!connection) {
-      throw Error(`Failed to read connection for sessionId:${sessionId}`);
-    }
-    const state = connection.state;
-    if (!state) {
-      throw Error(
-        `Failed to read state from connection for sessionId:${sessionId}`,
-      );
-    }
-
-    // Update interactionId
-    connection.state.interactionId = interactionId;
-
-    // Check if this is a tool call continuation
-    // If so, the tool result is already in messages (added by createConversationItem)
-    // We skip adding a new user message and just return the state to continue the conversation
-    if (text === TOOL_CALL_CONTINUATION_MARKER) {
-      logger.info({ sessionId, interactionId }, 'TextInputNode: Tool call continuation - skipping user message, continuing with existing conversation');
-      return connection.state;
-    }
-
-    // Normal flow: add user message to conversation
-    connection.state.messages.push({
-      role: 'user',
-      content: text,
-      id: interactionId,
-    });
-
-    return connection.state;
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts b/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
deleted file mode 100644
index ec6c6ac..0000000
--- a/realtime-service/src/components/graphs/nodes/text_output_stream_node.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-
-import { ConnectionsMap, State, TextInput } from '../../../types/index';
-import {TextStream} from "@inworld/runtime";
-
-/**
- * TextInputNode updates the state with the user's input this turn.
- *
- * This node:
- * - Takes input from Text Chunking Node as a text stream
- * - Outputs for graph handler to send to the client. Only used when modality is TextOnly
- */
-export class TextOutputStreamNode extends CustomNode {
-    private connections: ConnectionsMap;
-
-    constructor(props: {
-        id: string;
-        connections: ConnectionsMap;
-    }) {
-        super({
-            id: props.id,
-        });
-        this.connections = props.connections;
-    }
-
-    process(context: ProcessContext, input: TextStream): TextStream {
-        return input;
-    }
-}
diff --git a/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts b/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
deleted file mode 100644
index f3e8701..0000000
--- a/realtime-service/src/components/graphs/nodes/transcript_extractor_node.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { DataStreamWithMetadata } from '@inworld/runtime';
-import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-import { formatContext } from '../../../log-helpers';
-
-import { InteractionInfo } from '../../../types/index';
-
-/**
- * TranscriptExtractorNode extracts transcript information from
- * DataStreamWithMetadata (typically output from AssemblyAISTTNode)
- * and converts it to InteractionInfo for downstream processing.
- *
- * This is a helper node to bridge Assembly.AI STT output with
- * the rest of the graph that expects InteractionInfo.
- */
-export class TranscriptExtractorNode extends CustomNode {
-  constructor(props?: {
-    id?: string;
-    reportToClient?: boolean;
-  }) {
-    super({
-      id: props?.id || 'transcript-extractor-node',
-      reportToClient: props?.reportToClient,
-    });
-  }
-
-  /**
-   * Extract transcript from metadata and return as InteractionInfo
-   */
-  process(
-    context: ProcessContext,
-    streamWithMetadata: DataStreamWithMetadata,
-  ): InteractionInfo {
-    const metadata = streamWithMetadata.getMetadata();
-    const sessionId = context.getDatastore().get('sessionId') as string;
-
-    // Extract transcript and related info from metadata
-    const transcript = (metadata.transcript as string) || '';
-    const interactionComplete =
-      (metadata.interaction_complete as boolean) || false;
-    const iteration = (metadata.iteration as number) || 1;
-    const interactionId = String(metadata.interactionId || iteration);
-
-    logger.info({
-      sessionId,
-      interactionId,
-      iteration,
-      interactionComplete,
-      transcript,
-    }, `TranscriptExtractor processing [iteration:${iteration}]: "${transcript?.substring(0, 50)}..."`);
-
-    // Return InteractionInfo
-    return {
-      sessionId,
-      interactionId: interactionId,
-      text: transcript,
-    };
-  }
-
-  async destroy(): Promise<void> {
-    // No cleanup needed
-  }
-}
diff --git a/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts b/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
deleted file mode 100644
index f1a0c3a..0000000
--- a/realtime-service/src/components/graphs/nodes/tts_request_builder_node.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
-import logger from '../../../logger';
-import { formatSession } from '../../../log-helpers';
-import { ConnectionsMap } from '../../../types/index';
-
-/**
- * TTSRequestBuilderNode builds a TTSRequest with dynamic voiceId.
- * For long-running graphs, it reads voiceId from connection state at processing time
- * to ensure voice changes via session.update are reflected immediately.
- */
-export class TTSRequestBuilderNode extends CustomNode {
-  private connections: ConnectionsMap;
-  private defaultVoiceId: string;
-
-  constructor(props: {
-    id: string;
-    connections: ConnectionsMap;
-    defaultVoiceId: string;
-    reportToClient?: boolean;
-  }) {
-    super({
-      id: props.id,
-      reportToClient: props.reportToClient,
-    });
-    this.connections = props.connections;
-    this.defaultVoiceId = props.defaultVoiceId;
-  }
-
-  /**
-   * Build a TTSRequest with the current voiceId from connection state
-   * Receives two inputs:
-   * 1. input - Graph input with sessionId (TextInput or State)
-   * 2. textStream - The text stream from TextChunkingNode
-   */
-  process(
-    context: ProcessContext,
-    input: any,
-    textStream: GraphTypes.TextStream,
-  ): GraphTypes.TTSRequest {
-    const sessionId = context.getDatastore().get('sessionId') as string;
-    
-    // For long-running graphs, read voiceId from connection state at processing time
-    // This ensures voice changes via session.update are immediately reflected
-    const connection = this.connections[sessionId];
-    const voiceId = connection?.state?.voiceId || input?.voiceId || this.defaultVoiceId;
-    
-    logger.debug({
-      sessionId,
-      voiceId,
-      connectionVoiceId: connection?.state?.voiceId,
-      inputVoiceId: input?.voiceId,
-      defaultVoiceId: this.defaultVoiceId,
-    }, `TTSRequestBuilder building request [voice:${voiceId}]`);
-
-    return GraphTypes.TTSRequest.withStream(textStream, {
-      id: voiceId
-    });
-  }
-
-  async destroy(): Promise<void> {
-    // No cleanup needed
-  }
-}
-
diff --git a/realtime-service/src/components/graphs/realtime_graph_executor.ts b/realtime-service/src/components/graphs/realtime_graph_executor.ts
deleted file mode 100644
index f067470..0000000
--- a/realtime-service/src/components/graphs/realtime_graph_executor.ts
+++ /dev/null
@@ -1,1180 +0,0 @@
-import { GraphOutputStream, GraphTypes } from '@inworld/runtime/graph';
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../../logger';
-import * as RT from '../../types/realtime';
-import { InworldApp } from '../app';
-import { RealtimeEventFactory } from '../realtime/realtime_event_factory';
-import { InworldGraphWrapper } from '../graphs/graph';
-import { Connection } from '../../types/index';
-import { convertToPCM16Base64 } from '../audio/audio_utils';
-import { ToolCallInterface } from "@inworld/runtime";
-import { RealtimeSessionManager } from '../realtime/realtime_session_manager';
-import { MultimodalStreamManager } from '../audio/multimodal_stream_manager';
-import { abortStream } from '../../helpers';
-
-// Marker used to signal tool call continuation - the graph nodes recognize this
-// and skip adding a new user message, instead continuing with existing conversation state
-export const TOOL_CALL_CONTINUATION_MARKER = '[TOOL_CALL_CONTINUATION]';
-
-export class RealtimeGraphExecutor {
-  private isCancelled = false;
-  private currentTTSInteractionId: string | null = null;
-  private currentTranscriptionItemId: string | null = null;
-  private partialTranscripts: Map<string, string> = new Map();
-
-  constructor(
-    private inworldApp: InworldApp,
-    private sessionKey: string,
-    private send: (data: RT.ServerEvent) => void,
-    private sessionManager: RealtimeSessionManager,
-    private sessionStartTime: number
-  ) { }
-
-  cancelCurrentResponse(reason: 'turn_detected' | 'client_cancelled'): void {
-    const realtimeSession = this.sessionManager.getSession();
-    if (!realtimeSession.currentResponse || this.isCancelled) {
-      return; // Nothing to cancel or already cancelled
-    }
-    logger.info({
-      sessionId: this.sessionKey,
-      reason,
-      responseId: realtimeSession.currentResponse.id,
-      ttsInteractionId: this.currentTTSInteractionId || 'none',
-    }, 'Response Cancellation');
-
-    this.isCancelled = true;
-    const response = realtimeSession.currentResponse;
-
-    // Abort active content and TTS streams
-    abortStream(realtimeSession.currentContentStream, 'content stream', this.sessionKey, 'due to response cancellation');
-    realtimeSession.currentContentStream = null;
-
-    abortStream(realtimeSession.currentTTSStream, 'TTS stream', this.sessionKey, 'due to response cancellation');
-    realtimeSession.currentTTSStream = null;
-
-    response.status = 'cancelled';
-    response.status_details = { type: 'cancelled', reason };
-
-    this.send(RealtimeEventFactory.responseDone(response));
-    realtimeSession.currentResponse = null;
-  }
-
-  /**
-   * Execute audio graph with streaming multimodal input (audio and/or text)
-   */
-  async executeAudioGraph({
-    sessionId,
-    workspaceId,
-    apiKey,
-    input,
-    graphWrapper,
-    multimodalStreamManager,
-  }: {
-    sessionId: string;
-    workspaceId: string;
-    apiKey: string;
-    input: { sessionId: string; state: any };
-    graphWrapper: InworldGraphWrapper;
-    multimodalStreamManager: MultimodalStreamManager;
-  }): Promise<void> {
-    // Create a multimodal stream generator that yields MultimodalContent
-    async function* multimodalStreamGenerator() {
-      for await (const content of multimodalStreamManager.createStream()) {
-        yield content;
-      }
-    }
-
-    // Create the tagged stream with metadata
-    const taggedStream = Object.assign(multimodalStreamGenerator(), {
-      type: 'MultimodalContent',
-    });
-
-    const { outputStream } = await graphWrapper.graph.start(taggedStream, {
-      executionId: input.sessionId,
-      dataStoreContent: {
-        sessionId: input.sessionId,
-        state: input.state,
-      },
-      userContext: {
-        attributes: {
-          workspaceId: workspaceId,
-        },
-        targetingKey: uuidv4(),
-      },
-      userCredentials: {
-        inworldApiKey: apiKey,
-      },
-    });
-
-    const connection = this.inworldApp.connections[sessionId];
-    if (!connection) {
-      logger.debug({ sessionId }, 'Connection no longer exists, aborting audio graph execution');
-      outputStream.abort();
-      return;
-    }
-
-    // Store the execution stream so it can be aborted if needed
-    connection.currentAudioExecutionStream = outputStream;
-
-    // Handle multiple interactions from the stream
-    try {
-      let currentGraphInteractionId: string | undefined = undefined;
-      let resultCount = 0;
-
-      for await (const result of outputStream) {
-        resultCount++;
-        logger.debug({ sessionId, resultCount }, `Processing audio interaction #${resultCount}`);
-
-        // Check if result contains an error
-        if (result && result.isGraphError && result.isGraphError()) {
-          const errorData = result.data;
-          logger.error({
-            sessionId,
-            err: errorData,
-          }, 'Graph error');
-          if (!errorData.message.includes('recognition produced no text')) {
-            this.send(
-              RealtimeEventFactory.error({
-                type: 'graph_error',
-                message: errorData.message,
-              }),
-            );
-            if (errorData.code === 4) {
-              const connection = this.inworldApp.connections[sessionId];
-              if (connection?.ws) {
-                // Close the websocket connection
-                // Using code 1011 (Internal Error) as it's a server-side error
-                connection.ws.close(1011, 'JS Call Timeout. We will end the call if the audio stream is not active in 60 seconds.');
-              }
-            }
-          }
-          continue;
-        }
-
-        // Process the result - this will handle transcription, LLM response, and TTS
-        await this.processAudioGraphOutput(
-          result,
-          connection,
-          sessionId,
-          currentGraphInteractionId,
-        );
-      }
-
-      logger.info({ sessionId, resultCount }, `Audio stream processing complete: ${resultCount} interactions`);
-    } catch (error) {
-      logger.error({ err: error, sessionId }, 'Error processing audio stream');
-      throw error;
-    } finally {
-      // Clear the stream reference when done (if connection still exists)
-      const conn = this.inworldApp.connections[sessionId];
-      if (conn && conn.currentAudioExecutionStream === outputStream) {
-        conn.currentAudioExecutionStream = undefined;
-      }
-      // Clean up stream manager
-      connection.multimodalStreamManager = undefined;
-      connection.currentAudioGraphExecution = undefined;
-    }
-  }
-
-  /**
-   * Process a single result from the audio graph
-   */
-  private async processAudioGraphOutput(
-    result: any,
-    connection: Connection,
-    sessionId: string,
-    currentGraphInteractionId: string | undefined,
-  ): Promise<void> {
-    try {
-      logger.debug({
-        sessionId,
-        handlers: Object.keys(result),
-      }, 'Audio Graph Result - Processing result');
-
-      const realtimeSession = this.sessionManager.getSession();
-
-      await result.processResponse({
-        Content: async (content: GraphTypes.Content) => {
-          logger.debug({
-            sessionId,
-            hasContent: !!content.content,
-            contentLength: content.content?.length,
-            hasToolCalls: !!content.toolCalls,
-            toolCallsCount: content.toolCalls?.length,
-          }, 'Audio Graph - Content received');
-
-          if (content.toolCalls && content.toolCalls.length > 0) {
-            logger.info({ sessionId, toolCalls: content.toolCalls }, `Audio Graph - ${content.toolCalls.length} tool calls received`);
-          }
-        },
-        ContentStream: async (stream: GraphTypes.ContentStream) => {
-          // Ensure we have a response object
-          if (!realtimeSession.currentResponse) {
-            const responseId = uuidv4();
-            const response: RT.Response = {
-              id: responseId,
-              object: 'realtime.response',
-              status: 'in_progress',
-              status_details: null,
-              output: [],
-              conversation_id: 'conv_' + realtimeSession.id,
-              output_modalities: realtimeSession.session.output_modalities,
-              max_output_tokens: realtimeSession.session.max_output_tokens,
-              audio: {
-                output: realtimeSession.session.audio.output,
-              },
-              usage: null,
-              metadata: null,
-            };
-            realtimeSession.currentResponse = response;
-            this.send(RealtimeEventFactory.responseCreated(response));
-          }
-
-          await this.handleContentStream(stream, realtimeSession.currentResponse!, connection);
-        },
-        TTSOutputStream: async (ttsStream: GraphTypes.TTSOutputStream) => {
-          // Create a response if we don't have one
-          if (!realtimeSession.currentResponse) {
-            const responseId = uuidv4();
-            const response: RT.Response = {
-              id: responseId,
-              object: 'realtime.response',
-              status: 'in_progress',
-              status_details: null,
-              output: [],
-              conversation_id: 'conv_' + realtimeSession.id,
-              output_modalities: realtimeSession.session.output_modalities,
-              max_output_tokens: realtimeSession.session.max_output_tokens,
-              audio: {
-                output: realtimeSession.session.audio.output,
-              },
-              usage: null,
-              metadata: null,
-            };
-            realtimeSession.currentResponse = response;
-            this.send(RealtimeEventFactory.responseCreated(response));
-          }
-
-          await this.handleTTSOutputStream(ttsStream, realtimeSession.currentResponse!, connection, 'Audio Input');
-        },
-        TextStream: async (stream: GraphTypes.TextStream) => {
-          // Create a response if we don't have one
-          if (!realtimeSession.currentResponse) {
-            const responseId = uuidv4();
-            const response: RT.Response = {
-              id: responseId,
-              object: 'realtime.response',
-              status: 'in_progress',
-              status_details: null,
-              output: [],
-              conversation_id: 'conv_' + realtimeSession.id,
-              output_modalities: realtimeSession.session.output_modalities,
-              max_output_tokens: realtimeSession.session.max_output_tokens,
-              audio: {
-                output: realtimeSession.session.audio.output,
-              },
-              usage: null,
-              metadata: null,
-            };
-            realtimeSession.currentResponse = response;
-            this.send(RealtimeEventFactory.responseCreated(response));
-          }
-          await this.handleTextOutputStream(stream, realtimeSession.currentResponse!, connection, 'Audio Input');
-        },
-        Custom: async (customData: GraphTypes.Custom<any>) => {
-          // Handle custom events (transcription, etc)
-
-          // Check if it's a transcription event
-          if (('text' in customData || customData.type === 'TRANSCRIPT') && !('messages' in customData)) {
-            const transcript = (customData as any).text || '';
-            const interactionId = (customData as any).interactionId;
-            const isTextInput = (customData as any).is_text_input === true;
-
-            // Skip tool continuation marker - this is an internal marker, not a real transcript
-            if (transcript === TOOL_CALL_CONTINUATION_MARKER) {
-              logger.info({ sessionId, interactionId }, 
-                'Skipping transcription event for tool call continuation marker');
-              return;
-            }
-
-            if (transcript && transcript.trim().length > 0) {
-              const itemId = interactionId || uuidv4();
-              
-              // Check if this is a text input (simulated) - if so, skip transcription events
-              // Text inputs already have their conversation item created before being pushed to the graph
-              // We check:
-              // 1. If is_text_input flag is set in customData
-              // 2. If a conversation item with matching text already exists (text inputs create items first)
-              // 3. If the most recent user message matches this transcript (text inputs are processed immediately)
-              const existingItem = realtimeSession.conversationItems.find(
-                item => item.id === itemId || 
-                (item.role === 'user' && 
-                 item.content?.[0]?.type === 'input_text' && 
-                 item.content[0].text === transcript)
-              );
-              
-              // Also check the most recent user message (text inputs are typically the last item)
-              const lastUserItem = realtimeSession.conversationItems.length > 0
-                ? realtimeSession.conversationItems[realtimeSession.conversationItems.length - 1]
-                : null;
-              const isRecentTextInput = lastUserItem?.role === 'user' &&
-                lastUserItem?.content?.[0]?.type === 'input_text' &&
-                lastUserItem.content[0].text === transcript;
-
-              if (isTextInput || existingItem || isRecentTextInput) {
-                // This is a text input that was already processed
-                // Skip all transcription events since the conversation item already exists
-                logger.info({ sessionId, itemId, transcript: transcript.substring(0, 50) }, 
-                  `Skipping transcription events for text input (conversation item already exists)`);
-                return;
-              }
-
-              const audioStartMs = Date.now() - this.sessionStartTime;
-
-              // Send speech started event if we haven't already
-              if (!this.currentTranscriptionItemId) {
-                this.send(
-                  RealtimeEventFactory.inputAudioBufferSpeechStarted(audioStartMs, itemId),
-                );
-              }
-
-              this.currentTranscriptionItemId = itemId;
-
-              // Send speech stopped event
-              const audioEndMs = Date.now() - this.sessionStartTime;
-              this.send(
-                RealtimeEventFactory.inputAudioBufferSpeechStopped(audioEndMs, itemId),
-              );
-
-              const previousItemId =
-                realtimeSession.conversationItems.length > 0
-                  ? realtimeSession.conversationItems[
-                    realtimeSession.conversationItems.length - 1
-                  ].id
-                  : null;
-
-              // Send committed event
-              this.send(
-                RealtimeEventFactory.inputAudioBufferCommitted(itemId, previousItemId),
-              );
-
-              // Create conversation item for user transcription
-              const item: RT.ConversationItem = {
-                id: itemId,
-                type: 'message',
-                object: 'realtime.item',
-                status: 'completed',
-                role: 'user',
-                content: [
-                  {
-                    type: 'input_text',
-                    text: transcript,
-                  },
-                ],
-              };
-
-              realtimeSession.conversationItems.push(item);
-              this.send(RealtimeEventFactory.conversationItemAdded(item, previousItemId));
-
-              // Send transcription completed event
-              logger.info({ sessionId, transcript, itemId }, `Transcription completed: "${transcript.substring(0, 50)}..."`);
-              this.send(
-                RealtimeEventFactory.inputAudioTranscriptionCompleted(
-                  itemId,
-                  0,
-                  transcript,
-                ),
-              );
-
-              this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
-
-              // Clear the transcription item ID
-              this.currentTranscriptionItemId = null;
-              this.partialTranscripts.delete(itemId);
-            }
-          }
-        },
-        error: async (error: GraphTypes.GraphError) => {
-          logger.error({ sessionId, err: error }, 'Graph error');
-          // Don't send errors for empty speech recognition
-          if (!error.message.includes('recognition produced no text')) {
-            this.send(
-              RealtimeEventFactory.error({
-                type: 'server_error',
-                message: error.message,
-              }),
-            );
-          }
-        },
-      });
-    } catch (error) {
-      logger.error({ sessionId, err: error }, 'Error processing audio graph result');
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'server_error',
-          message: error instanceof Error ? error.message : 'Unknown error processing audio graph result',
-        }),
-      );
-    }
-  }
-
-  /**
-   * Process ContentStream for tool calls (shared between audio and text graphs)
-   */
-  private async handleContentStream(
-    stream: GraphTypes.ContentStream,
-    response: RT.Response,
-    connection: Connection,
-  ): Promise<void> {
-    const realtimeSession = this.sessionManager.getSession();
-    const toolCallState = new Map<string, { item: RT.ConversationItem; args: string }>();
-
-    // Store the stream object so it can be aborted
-    realtimeSession.currentContentStream = stream;
-
-    try {
-      for await (const chunk of stream) {
-        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
-          await this.handleToolCallChunk(chunk.toolCalls, response, toolCallState);
-        }
-      }
-    } finally {
-      // Clear the stream reference when done
-      realtimeSession.currentContentStream = null;
-    }
-
-    // Send completion events for all tool calls
-    for (const [callId, state] of toolCallState.entries()) {
-      const outputIndex = response.output.indexOf(state.item);
-
-      // Update the item with final arguments
-      state.item.arguments = state.args;
-      state.item.status = 'completed';
-
-      // Send done event
-      this.send(
-        RealtimeEventFactory.responseFunctionCallArgumentsDone(
-          response.id,
-          state.item.id!,
-          outputIndex,
-          callId,
-          state.args,
-        ),
-      );
-
-      this.send(
-        RealtimeEventFactory.conversationItemDone(state.item),
-      );
-
-      this.send(
-        RealtimeEventFactory.responseOutputItemDone(
-          response.id,
-          outputIndex,
-          state.item,
-        ),
-      );
-
-      // Add to conversation items
-      realtimeSession.conversationItems.push(state.item);
-
-      // Add a minimal assistant message
-      connection.state.messages.push({
-        role: 'assistant',
-        content: '[Function call executed]',
-        id: connection.state.interactionId,
-      });
-    }
-  }
-
-  /**
-   * Process TextOutputStream for text-only messages
-   */
-  private async handleTextOutputStream(
-    stream: GraphTypes.TextStream,
-    response: RT.Response,
-    connection: Connection,
-    logPrefix: string,
-  ): Promise<RT.ConversationItem | undefined> {
-    const realtimeSession = this.sessionManager.getSession();
-    const isTextOnly =
-      response.output_modalities?.includes('text') &&
-      !response.output_modalities?.includes('audio');
-
-    let item: RT.ConversationItem | undefined;
-    let itemId: string | undefined;
-    let outputIndex: number | undefined;
-    let contentPart: RT.ContentPart | undefined;
-    const contentIndex = 0;
-
-    if (!isTextOnly) {
-      logger.info('[Text Output Stream] should not be called when modality is not text only!');
-      return item;
-    }
-
-    // Process text stream chunks
-    for await (const chunk of stream) {
-      // Extract text from chunk (handle both string and object with text property)
-      const text = typeof chunk === 'string' ? chunk : (chunk?.text || chunk?.toString() || '');
-
-      if (!text || text === '') {
-        continue;
-      }
-
-      // Lazy create item on first chunk
-      if (!item) {
-        itemId = uuidv4();
-        outputIndex = response.output.length;
-
-        item = {
-          id: itemId,
-          type: 'message',
-          object: 'realtime.item',
-          status: 'in_progress',
-          role: 'assistant',
-          content: [],
-        };
-
-        const previousItemId =
-          realtimeSession.conversationItems.length > 0
-            ? realtimeSession.conversationItems[
-              realtimeSession.conversationItems.length - 1
-            ].id
-            : null;
-
-        response.output.push(item);
-        this.send(
-          RealtimeEventFactory.responseOutputItemAdded(response.id, outputIndex, item),
-        );
-        this.send(
-          RealtimeEventFactory.conversationItemAdded(item, previousItemId),
-        );
-
-        contentPart = { type: 'text', text: '' };
-
-        item.content = [contentPart];
-        this.send(
-          RealtimeEventFactory.responseContentPartAdded(
-            response.id,
-            itemId,
-            outputIndex,
-            contentIndex,
-            contentPart,
-          ),
-        );
-
-        // Track that we're streaming text for this interaction
-        const textInteractionId = connection.state.interactionId;
-        this.isCancelled = false;
-
-        logger.info({ sessionId: this.sessionKey, textInteractionId, logPrefix }, `Text stream starting (${logPrefix})`);
-      }
-
-      if (this.isCancelled) {
-        logger.info(`[Text Output] Stopping text stream - response was cancelled`);
-        break;
-      }
-
-      // Send text delta event
-      this.send(
-        RealtimeEventFactory.responseTextDelta(
-          response.id,
-          itemId!,
-          outputIndex!,
-          contentIndex,
-          text,
-        ),
-      );
-      // logger.info(`[TEXT DELTA] - ${text}`);
-      contentPart!.text = (contentPart!.text || '') + text;
-    }
-
-    // Send completion events or mark as incomplete
-    if (item) {
-      if (this.isCancelled) {
-        item.status = 'incomplete';
-      } else {
-        const previousItemId =
-          realtimeSession.conversationItems.length > 0
-            ? realtimeSession.conversationItems[
-              realtimeSession.conversationItems.length - 1
-            ].id
-            : null;
-
-        // Send text completion event
-        this.send(RealtimeEventFactory.responseTextDone(
-          response.id, itemId!, outputIndex!, contentIndex, contentPart!.text || ''
-        ));
-
-        // Send common completion events
-        this.send(RealtimeEventFactory.responseContentPartDone(
-          response.id, itemId!, outputIndex!, contentIndex, contentPart!
-        ));
-        this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
-
-        item.status = 'completed';
-        this.send(RealtimeEventFactory.responseOutputItemDone(response.id, outputIndex!, item));
-      }
-
-      // Add to conversation items
-      realtimeSession.conversationItems.push(item);
-    }
-
-    return item;
-  }
-
-  /**
-   * Process TTSOutputStream for audio messages
-   * Note: Text-only modality is handled by handleTextOutputStream
-   */
-  private async handleTTSOutputStream(
-    ttsStream: GraphTypes.TTSOutputStream,
-    response: RT.Response,
-    connection: Connection,
-    logPrefix: string,
-  ): Promise<RT.ConversationItem | undefined> {
-    const realtimeSession = this.sessionManager.getSession();
-    const isTextOnly =
-      response.output_modalities?.includes('text') &&
-      !response.output_modalities?.includes('audio');
-
-    // Warn if called with text-only modality (should use handleTextOutputStream instead)
-    if (isTextOnly) {
-      logger.warn('[TTS Output Stream] Called with text-only modality - should use handleTextOutputStream instead');
-    }
-
-    let item: RT.ConversationItem | undefined;
-    let itemId: string | undefined;
-    let outputIndex: number | undefined;
-    let contentPart: RT.ContentPart | undefined;
-    const contentIndex = 0;
-
-    // Store the TTSOutputStream object so it can be aborted using its abort() method
-    realtimeSession.currentTTSStream = ttsStream;
-
-    try {
-      // Process TTS stream chunks
-      for await (const chunk of ttsStream) {
-        // Lazy create item on first chunk
-        if (!item) {
-          itemId = uuidv4();
-          outputIndex = response.output.length;
-
-          item = {
-            id: itemId,
-            type: 'message',
-            object: 'realtime.item',
-            status: 'in_progress',
-            role: 'assistant',
-            content: [],
-          };
-
-          const previousItemId =
-            realtimeSession.conversationItems.length > 0
-              ? realtimeSession.conversationItems[
-                realtimeSession.conversationItems.length - 1
-              ].id
-              : null;
-
-          response.output.push(item);
-          this.send(
-            RealtimeEventFactory.responseOutputItemAdded(response.id, outputIndex, item),
-          );
-          this.send(
-            RealtimeEventFactory.conversationItemAdded(item, previousItemId),
-          );
-
-          // Always create audio content part (text-only is handled elsewhere)
-          contentPart = { type: 'audio', transcript: '' };
-
-          item.content = [contentPart];
-          this.send(
-            RealtimeEventFactory.responseContentPartAdded(
-              response.id,
-              itemId,
-              outputIndex,
-              contentIndex,
-              contentPart,
-            ),
-          );
-
-          // Track that we're streaming TTS for this interaction
-          const ttsInteractionId = connection.state.interactionId;
-          this.currentTTSInteractionId = ttsInteractionId;
-          this.isCancelled = false;
-
-          logger.info(`[TTS] Starting stream for ${ttsInteractionId} (${logPrefix})`);
-        }
-
-        if (this.isCancelled) {
-          logger.info(`[TTS] Stopping TTS stream - response was cancelled`);
-          break;
-        }
-
-        // Process audio chunk
-        if (chunk.text != null && chunk.text !== '') {
-          this.send(
-            RealtimeEventFactory.responseAudioTranscriptDelta(
-              response.id,
-              itemId!,
-              outputIndex!,
-              contentIndex,
-              chunk.text,
-            ),
-          );
-        }
-
-        // Convert audio data to PCM16 base64
-        const audioBase64 = convertToPCM16Base64(
-          chunk.audio?.data,
-          chunk.audio?.sampleRate,
-          `TTS Audio (${logPrefix})`
-        );
-
-        if (!audioBase64) {
-          continue;
-        }
-
-        // Send audio delta
-        this.send(
-          RealtimeEventFactory.responseAudioDelta(
-            response.id,
-            itemId!,
-            outputIndex!,
-            contentIndex,
-            audioBase64,
-          ),
-        );
-
-        // Update transcript
-        if (chunk.text) {
-          contentPart!.transcript = (contentPart!.transcript || '') + chunk.text;
-        }
-      }
-
-      // Send completion events or mark as incomplete
-      if (item) {
-        if (this.isCancelled) {
-          item.status = 'incomplete';
-        } else {
-          const previousItemId =
-            realtimeSession.conversationItems.length > 0
-              ? realtimeSession.conversationItems[
-                realtimeSession.conversationItems.length - 1
-              ].id
-              : null;
-
-          // Send audio completion events
-          this.send(RealtimeEventFactory.responseAudioTranscriptDone(
-            response.id, itemId!, outputIndex!, contentIndex, contentPart!.transcript || ''
-          ));
-          this.send(RealtimeEventFactory.responseAudioDone(
-            response.id, itemId!, outputIndex!, contentIndex
-          ));
-
-          // Send common completion events
-          this.send(RealtimeEventFactory.responseContentPartDone(
-            response.id, itemId!, outputIndex!, contentIndex, contentPart!
-          ));
-          this.send(RealtimeEventFactory.conversationItemDone(item, previousItemId));
-
-          item.status = 'completed';
-          this.send(RealtimeEventFactory.responseOutputItemDone(response.id, outputIndex!, item));
-
-          // Clear TTS tracking on successful completion
-          this.currentTTSInteractionId = null;
-        }
-
-        // Add to conversation items
-        realtimeSession.conversationItems.push(item);
-      }
-
-      return item;
-    } catch (error) {
-      // Check if this is a cancellation error (expected when response is cancelled)
-      const isCancellationError =
-        this.isCancelled &&
-        error instanceof Error &&
-        error.message.includes('Operation cancelled');
-
-      if (isCancellationError) {
-        logger.debug({ sessionId: this.sessionKey }, 'TTS stream cancelled (expected during response cancellation)');
-
-        // Mark item as incomplete if we had started creating one
-        if (item) {
-          item.status = 'incomplete';
-          realtimeSession.conversationItems.push(item);
-        }
-        return item;
-      }
-
-      // Re-throw unexpected errors
-      throw error;
-    } finally {
-      // Clear the stream reference when done
-      realtimeSession.currentTTSStream = null;
-    }
-  }
-
-  /**
-   * Handle tool call chunks from LLM stream
-   */
-  private async handleToolCallChunk(
-    toolCalls: ToolCallInterface[],
-    response: RT.Response,
-    toolCallState: Map<string, { item: RT.ConversationItem; args: string }>,
-  ): Promise<void> {
-    for (const toolCall of toolCalls) {
-      const callId = toolCall.id;
-
-      if (!toolCallState.has(callId)) {
-        // New tool call
-        const itemId = uuidv4();
-        const outputIndex = response.output.length;
-        const item: RT.ConversationItem = {
-          id: itemId,
-          type: 'function_call',
-          object: 'realtime.item',
-          status: 'in_progress',
-          call_id: callId,
-          name: toolCall.name,
-          arguments: '',
-        };
-
-        response.output.push(item);
-        this.send(
-          RealtimeEventFactory.responseOutputItemAdded(
-            response.id,
-            outputIndex,
-            item,
-          ),
-        );
-        this.send(RealtimeEventFactory.conversationItemAdded(item));
-
-        toolCallState.set(callId, { item, args: toolCall.args || '' });
-
-        if (toolCall.args) {
-          this.send(
-            RealtimeEventFactory.responseFunctionCallArgumentsDelta(
-              response.id,
-              item.id!,
-              outputIndex,
-              callId,
-              toolCall.args,
-            ),
-          );
-        }
-      } else {
-        // Existing tool call
-        const state = toolCallState.get(callId)!;
-
-        if (toolCall.args) {
-          state.args += toolCall.args;
-
-          const outputIndex = response.output.indexOf(state.item);
-
-          this.send(
-            RealtimeEventFactory.responseFunctionCallArgumentsDelta(
-              response.id,
-              state.item.id!,
-              outputIndex,
-              callId,
-              toolCall.args,
-            ),
-          );
-        }
-      }
-    }
-  }
-
-  /**
-   * Handle partial transcription updates from AssemblyAI.
-   */
-  handlePartialTranscriptDelta(
-    interactionId: string,
-    text: string,
-  ): void {
-    if (!interactionId || typeof text !== 'string') {
-      return;
-    }
-
-    const previous = this.partialTranscripts.get(interactionId) ?? '';
-
-    if (text === previous) {
-      return;
-    }
-
-    // Track that this interaction is the active transcription
-    this.currentTranscriptionItemId = interactionId;
-
-    // Compute the longest common prefix to determine the delta
-    const commonPrefixLength = this.getCommonPrefixLength(previous, text);
-    const deletions = previous.length - commonPrefixLength;
-    let delta = '';
-
-    if (deletions > 0) {
-      delta += '\b'.repeat(deletions);
-    }
-
-    delta += text.slice(commonPrefixLength);
-
-    if (!delta) {
-      return;
-    }
-
-    this.partialTranscripts.set(interactionId, text);
-
-    this.send(
-      RealtimeEventFactory.inputAudioTranscriptionDelta(
-        interactionId,
-        0,
-        delta,
-      ),
-    );
-  }
-
-  private getCommonPrefixLength(a: string, b: string): number {
-    const maxLen = Math.min(a.length, b.length);
-    let idx = 0;
-    while (idx < maxLen && a[idx] === b[idx]) {
-      idx++;
-    }
-    return idx;
-  }
-
-  /**
-   * Create a response from the model
-   */
-  async createResponse(inputItemId?: string): Promise<void> {
-    // Reset cancellation flag for new response
-    this.isCancelled = false;
-
-    const realtimeSession = this.sessionManager.getSession();
-    const responseId = uuidv4();
-    const response: RT.Response = {
-      id: responseId,
-      object: 'realtime.response',
-      status: 'in_progress',
-      status_details: null,
-      output: [],
-      conversation_id: 'conv_' + realtimeSession.id,
-      output_modalities: realtimeSession.session.output_modalities,
-      max_output_tokens: realtimeSession.session.max_output_tokens,
-      audio: {
-        output: realtimeSession.session.audio.output,
-      },
-      usage: null,
-      metadata: null,
-    };
-
-    realtimeSession.currentResponse = response;
-    this.send(RealtimeEventFactory.responseCreated(response));
-
-    try {
-      const connection = this.inworldApp.connections[this.sessionKey];
-      
-      // Check if this is a tool call continuation (response.create after function_call_output)
-      const lastItem = realtimeSession.conversationItems.length > 0
-        ? realtimeSession.conversationItems[realtimeSession.conversationItems.length - 1]
-        : null;
-      
-      const isToolCallContinuation = lastItem?.type === 'function_call_output';
-      
-      if (isToolCallContinuation) {
-        // This is a continuation after a tool call - the tool result is already in connection.state.messages
-        // We need to trigger the LLM with the current conversation state
-        logger.info({ sessionId: this.sessionKey, callId: lastItem.call_id }, 'Tool call continuation - triggering LLM with tool result');
-        
-        if (!connection) {
-          throw new Error('No connection found for session');
-        }
-        
-        // Trigger the LLM via the audio graph with a tool continuation marker
-        // This will be recognized by the graph and processed without adding a new user message
-        await this.handleToolCallContinuation(connection, response);
-        return;
-      }
-
-      // Find the most recent user message to process
-      let userMessage: RT.ConversationItem | undefined;
-
-      if (inputItemId) {
-        userMessage = realtimeSession.conversationItems.find(
-          (i) => i.id === inputItemId,
-        );
-      } else {
-        // Find the last user message
-        for (let i = realtimeSession.conversationItems.length - 1; i >= 0; i--) {
-          const item = realtimeSession.conversationItems[i];
-          if (item.role === 'user') {
-            userMessage = item;
-            break;
-          }
-        }
-      }
-
-      if (!userMessage || !userMessage.content || userMessage.content.length === 0) {
-        // Send error event instead of throwing
-        response.status = 'failed';
-        response.status_details = {
-          type: 'failed',
-          error: {
-            type: 'invalid_request_error',
-            code: 'no_user_message',
-          },
-        };
-        this.send(RealtimeEventFactory.responseDone(response));
-        this.send(
-          RealtimeEventFactory.error({
-            type: 'invalid_request_error',
-            code: 'no_user_message',
-            message: 'No user message found to generate response. Please create a conversation item before requesting a response.',
-          }),
-        );
-        realtimeSession.currentResponse = null;
-        return;
-      }
-
-      const content = userMessage.content[0];
-      let input: any;
-
-      if (content.type === 'input_text' && content.text) {
-        // Text inputs are processed through the continuous multimodal stream
-        // The graph runs continuously and automatically sends response events for each turn
-        // DO NOT wait for graph completion - it runs until the stream is ended
-        const hasActiveAudioGraph = connection?.currentAudioGraphExecution !== undefined;
-        
-        if (hasActiveAudioGraph) {
-          // Graph is running and processing text turns continuously
-          // Response events are sent automatically by processAudioGraphOutput
-          // Just acknowledge and return - don't block
-          logger.info({ sessionId: this.sessionKey, responseId },
-            'Text input being processed by continuous graph - response events sent automatically');
-        } else {
-          // No active graph - text should have been pushed via conversation.item.create first
-          logger.warn({ sessionId: this.sessionKey },
-            'No active graph for text input - ensure conversation.item.create was called first');
-        }
-
-        // Cancel this response.create since the graph handles responses automatically
-        this.isCancelled = true;
-        realtimeSession.currentResponse = null;
-        return;
-      } else {
-        // For audio input, it should have been handled by the audio graph already?
-        // Or if we manually trigger response creation on an existing audio item?
-        // If content.type is input_audio, we probably can't easily re-run it through the text graph
-        // unless we have the transcript.
-        // But the logic in original file threw error.
-        throw new Error(`Unsupported content type: ${content.type}`);
-      }
-
-      // Don't mark as completed if already cancelled
-      if (!this.isCancelled) {
-        // Mark response as completed
-        response.status = 'completed';
-        response.status_details = { type: 'completed' };
-      }
-    } catch (error) {
-      logger.error({ err: error, sessionId: this.sessionKey }, 'Error creating response');
-      response.status = 'failed';
-      response.status_details = {
-        type: 'failed',
-        error: {
-          type: 'server_error',
-          code: 'internal_error',
-        },
-      };
-      // Send error to websocket
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'server_error',
-          message: error instanceof Error ? error.message : 'Error creating response',
-        }),
-      );
-    }
-
-    // Only send response.done if not already cancelled
-    if (!this.isCancelled) {
-      this.send(RealtimeEventFactory.responseDone(response));
-      realtimeSession.currentResponse = null;
-    }
-  }
-
-  /**
-   * Handle tool call continuation by triggering the LLM with the current conversation state.
-   * The tool result is already in connection.state.messages (added by createConversationItem).
-   * This method triggers the graph without adding a new user message.
-   */
-  private async handleToolCallContinuation(
-    connection: Connection,
-    response: RT.Response,
-  ): Promise<void> {
-    const realtimeSession = this.sessionManager.getSession();
-    
-    try {
-      // Create a multimodal stream manager for this continuation
-      const multimodalStreamManager = new MultimodalStreamManager();
-      connection.multimodalStreamManager = multimodalStreamManager;
-      
-      const session = realtimeSession.session;
-      
-      // Start the audio graph execution with the stream
-      const audioStreamInput = {
-        sessionId: this.sessionKey,
-        state: connection.state,
-        voiceId: connection.state.voiceId || session.audio.output.voice,
-      };
-      
-      // Use the Assembly.AI audio graph
-      const graphWrapper = this.inworldApp.graphWithAudioInput;
-      
-      // Push a special tool continuation marker that the graph nodes will recognize
-      // This signals that we're continuing after a tool call and shouldn't add a new user message
-      multimodalStreamManager.pushText(TOOL_CALL_CONTINUATION_MARKER);
-      
-      // Start graph execution and wait for completion
-      connection.currentAudioGraphExecution = this.executeAudioGraph({
-        sessionId: this.sessionKey,
-        workspaceId: connection.workspaceId,
-        apiKey: connection.apiKey,
-        input: audioStreamInput,
-        graphWrapper,
-        multimodalStreamManager,
-      });
-      
-      await connection.currentAudioGraphExecution;
-      
-      // Response should have been handled by the audio graph output processing
-      // Mark as completed if not already done
-      if (!this.isCancelled && realtimeSession.currentResponse?.id === response.id) {
-        response.status = 'completed';
-        response.status_details = { type: 'completed' };
-        this.send(RealtimeEventFactory.responseDone(response));
-        realtimeSession.currentResponse = null;
-      }
-    } catch (error) {
-      logger.error({ err: error, sessionId: this.sessionKey }, 'Error in tool call continuation');
-      response.status = 'failed';
-      response.status_details = {
-        type: 'failed',
-        error: {
-          type: 'server_error',
-          code: 'tool_continuation_error',
-        },
-      };
-      this.send(RealtimeEventFactory.responseDone(response));
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'server_error',
-          message: error instanceof Error ? error.message : 'Error in tool call continuation',
-        }),
-      );
-      realtimeSession.currentResponse = null;
-    } finally {
-      // Clean up
-      connection.multimodalStreamManager = undefined;
-      connection.currentAudioGraphExecution = undefined;
-    }
-  }
-}
-
diff --git a/realtime-service/src/components/realtime/realtime_event_factory.ts b/realtime-service/src/components/realtime/realtime_event_factory.ts
deleted file mode 100644
index 1e94d4e..0000000
--- a/realtime-service/src/components/realtime/realtime_event_factory.ts
+++ /dev/null
@@ -1,499 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import * as RT from '../../types/realtime';
-
-/**
- * Factory for creating OpenAI Realtime API server events
- */
-export class RealtimeEventFactory {
-  /**
-   * Create a session.created event
-   */
-  static sessionCreated(session: RT.Session): RT.SessionCreatedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'session.created',
-      session,
-    };
-  }
-
-  /**
-   * Create a session.updated event
-   */
-  static sessionUpdated(session: RT.Session): RT.SessionUpdatedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'session.updated',
-      session,
-    };
-  }
-
-  /**
-   * Create a conversation.item.added event
-   */
-  static conversationItemAdded(
-    item: RT.ConversationItem,
-    previousItemId: string | null = null,
-  ): RT.ConversationItemAddedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.added',
-      previous_item_id: previousItemId,
-      item,
-    };
-  }
-
-  /**
-   * Create a conversation.item.done event
-   */
-  static conversationItemDone(
-    item: RT.ConversationItem,
-    previousItemId: string | null = null,
-  ): RT.ConversationItemDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.done',
-      previous_item_id: previousItemId,
-      item,
-    };
-  }
-
-  /**
-   * Create a conversation.item.retrieved event
-   */
-  static conversationItemRetrieved(
-    item: RT.ConversationItem,
-  ): RT.ConversationItemRetrievedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.retrieved',
-      item,
-    };
-  }
-
-  /**
-   * Create a conversation.item.truncated event
-   */
-  static conversationItemTruncated(
-    itemId: string,
-    contentIndex: number,
-    audioEndMs: number,
-  ): RT.ConversationItemTruncatedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.truncated',
-      item_id: itemId,
-      content_index: contentIndex,
-      audio_end_ms: audioEndMs,
-    };
-  }
-
-  /**
-   * Create a conversation.item.deleted event
-   */
-  static conversationItemDeleted(
-    itemId: string,
-  ): RT.ConversationItemDeletedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.deleted',
-      item_id: itemId,
-    };
-  }
-
-  /**
-   * Create an input_audio_buffer.speech_started event
-   */
-  static inputAudioBufferSpeechStarted(
-    audioStartMs: number,
-    itemId: string,
-  ): RT.InputAudioBufferSpeechStartedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'input_audio_buffer.speech_started',
-      audio_start_ms: audioStartMs,
-      item_id: itemId,
-    };
-  }
-
-  /**
-   * Create an input_audio_buffer.speech_stopped event
-   */
-  static inputAudioBufferSpeechStopped(
-    audioEndMs: number,
-    itemId: string,
-  ): RT.InputAudioBufferSpeechStoppedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'input_audio_buffer.speech_stopped',
-      audio_end_ms: audioEndMs,
-      item_id: itemId,
-    };
-  }
-
-  /**
-   * Create an input_audio_buffer.committed event
-   */
-  static inputAudioBufferCommitted(
-    itemId: string,
-    previousItemId: string | null = null,
-  ): RT.InputAudioBufferCommittedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'input_audio_buffer.committed',
-      previous_item_id: previousItemId,
-      item_id: itemId,
-    };
-  }
-
-  /**
-   * Create an input_audio_buffer.cleared event
-   */
-  static inputAudioBufferCleared(): RT.InputAudioBufferClearedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'input_audio_buffer.cleared',
-    };
-  }
-
-  /**
-   * Create a conversation.item.input_audio_transcription.delta event
-   */
-  static inputAudioTranscriptionDelta(
-    itemId: string,
-    contentIndex: number,
-    delta: string,
-  ): RT.ConversationItemInputAudioTranscriptionDeltaEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.input_audio_transcription.delta',
-      item_id: itemId,
-      content_index: contentIndex,
-      delta,
-    };
-  }
-
-  /**
-   * Create a conversation.item.input_audio_transcription.completed event
-   */
-  static inputAudioTranscriptionCompleted(
-    itemId: string,
-    contentIndex: number,
-    transcript: string,
-  ): RT.ConversationItemInputAudioTranscriptionCompletedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'conversation.item.input_audio_transcription.completed',
-      item_id: itemId,
-      content_index: contentIndex,
-      transcript,
-    };
-  }
-
-  /**
-   * Create a response.created event
-   */
-  static responseCreated(response: RT.Response): RT.ResponseCreatedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.created',
-      response,
-    };
-  }
-
-
-  /**
-   * Create a response.done event
-   */
-  static responseDone(response: RT.Response): RT.ResponseDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.done',
-      response,
-    };
-  }
-
-  /**
-   * Create a response.output_item.added event
-   */
-  static responseOutputItemAdded(
-    responseId: string,
-    outputIndex: number,
-    item: RT.ConversationItem,
-  ): RT.ResponseOutputItemAddedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_item.added',
-      response_id: responseId,
-      output_index: outputIndex,
-      item,
-    };
-  }
-
-  /**
-   * Create a response.output_item.done event
-   */
-  static responseOutputItemDone(
-    responseId: string,
-    outputIndex: number,
-    item: RT.ConversationItem,
-  ): RT.ResponseOutputItemDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_item.done',
-      response_id: responseId,
-      output_index: outputIndex,
-      item,
-    };
-  }
-
-  /**
-   * Create a response.content_part.added event
-   */
-  static responseContentPartAdded(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    part: RT.ContentPart,
-  ): RT.ResponseContentPartAddedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.content_part.added',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      part,
-    };
-  }
-
-  /**
-   * Create a response.content_part.done event
-   */
-  static responseContentPartDone(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    part: RT.ContentPart,
-  ): RT.ResponseContentPartDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.content_part.done',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      part,
-    };
-  }
-
-  /**
-   * Create a response.output_audio.delta event
-   */
-  static responseAudioDelta(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    delta: string,
-  ): RT.ResponseAudioDeltaEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_audio.delta',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      delta,
-    };
-  }
-
-  /**
-   * Create a response.output_audio.done event
-   */
-  static responseAudioDone(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-  ): RT.ResponseAudioDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_audio.done',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-    };
-  }
-
-  /**
-   * Create a response.output_audio_transcript.delta event
-   */
-  static responseAudioTranscriptDelta(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    delta: string,
-  ): RT.ResponseAudioTranscriptDeltaEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_audio_transcript.delta',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      delta,
-    };
-  }
-
-  /**
-   * Create a response.output_audio_transcript.done event
-   */
-  static responseAudioTranscriptDone(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    transcript: string,
-  ): RT.ResponseAudioTranscriptDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_audio_transcript.done',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      transcript,
-    };
-  }
-
-  /**
-   * Create a response.function_call_arguments.delta event
-   */
-  static responseFunctionCallArgumentsDelta(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    callId: string,
-    delta: string,
-  ): RT.ResponseFunctionCallArgumentsDeltaEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.function_call_arguments.delta',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      call_id: callId,
-      delta,
-    };
-  }
-
-  /**
-   * Create a response.function_call_arguments.done event
-   */
-  static responseFunctionCallArgumentsDone(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    callId: string,
-    args: string,
-  ): RT.ResponseFunctionCallArgumentsDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.function_call_arguments.done',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      call_id: callId,
-      arguments: args,
-    };
-  }
-
-  /**
-   * Create a response.output_text.delta event
-   */
-  static responseTextDelta(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    delta: string,
-  ): RT.ResponseTextDeltaEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_text.delta',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      delta,
-    };
-  }
-
-  /**
-   * Create a response.output_text.done event
-   */
-  static responseTextDone(
-    responseId: string,
-    itemId: string,
-    outputIndex: number,
-    contentIndex: number,
-    text: string,
-  ): RT.ResponseTextDoneEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'response.output_text.done',
-      response_id: responseId,
-      item_id: itemId,
-      output_index: outputIndex,
-      content_index: contentIndex,
-      text,
-    };
-  }
-
-  /**
-   * Create an error event
-   */
-  static error(
-    error: {
-      type: string;
-      code?: string;
-      message: string;
-      param?: string;
-      event_id?: string;
-    },
-  ): RT.ErrorEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'error',
-      error: {
-        type: error.type,
-        code: error.code || null,
-        message: error.message,
-        param: error.param || null,
-        event_id: error.event_id || null,
-      },
-    };
-  }
-
-  /**
-   * Create a rate_limits.updated event
-   */
-  static rateLimitsUpdated(
-    rateLimits: Array<{
-      name: 'requests' | 'tokens';
-      limit: number;
-      remaining: number;
-      reset_seconds: number;
-    }>,
-  ): RT.RateLimitsUpdatedEvent {
-    return {
-      event_id: uuidv4(),
-      type: 'rate_limits.updated',
-      rate_limits: rateLimits,
-    };
-  }
-}
diff --git a/realtime-service/src/components/realtime/realtime_message_handler.ts b/realtime-service/src/components/realtime/realtime_message_handler.ts
deleted file mode 100644
index 7b35140..0000000
--- a/realtime-service/src/components/realtime/realtime_message_handler.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-import { RawData } from 'ws';
-import logger from '../../logger';
-import { formatContext, formatSession, formatError } from '../../log-helpers';
-import * as RT from '../../types/realtime';
-import { InworldApp } from '../app';
-import { RealtimeEventFactory } from './realtime_event_factory';
-import { RealtimeSessionManager } from './realtime_session_manager';
-import { RealtimeAudioHandler } from '../audio/realtime_audio_handler';
-import { RealtimeGraphExecutor } from '../graphs/realtime_graph_executor';
-
-export class RealtimeMessageHandler {
-  private sessionManager: RealtimeSessionManager;
-  private audioHandler: RealtimeAudioHandler;
-  private graphExecutor: RealtimeGraphExecutor;
-  private processingQueue: (() => Promise<void>)[] = [];
-  private isProcessing = false;
-  private sessionStartTime: number = Date.now();
-
-  constructor(
-    private inworldApp: InworldApp,
-    private sessionKey: string,
-    private send: (data: RT.ServerEvent) => void,
-  ) {
-    this.sessionManager = new RealtimeSessionManager(inworldApp, sessionKey, send, this.sessionStartTime);
-    this.graphExecutor = new RealtimeGraphExecutor(inworldApp, sessionKey, send, this.sessionManager, this.sessionStartTime);
-    this.audioHandler = new RealtimeAudioHandler(inworldApp, sessionKey, send, this.graphExecutor, this.sessionManager);
-  }
-
-  async initialize(): Promise<void> {
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (connection) {
-      connection.state.voiceId = this.sessionManager.getSession().session.audio.output.voice;
-
-      connection.onSpeechDetected = (interactionId: string) => {
-        logger.info(
-          { interactionId, sessionId: this.sessionKey },
-          `Speech detected ${formatContext(this.sessionKey, undefined, interactionId)}`
-        );
-
-        this.send(RealtimeEventFactory.inputAudioBufferSpeechStarted(
-          Date.now() - this.sessionStartTime, // audio_start_ms
-          interactionId // item_id
-        ));
-      };
-
-      // Partial transcript callback
-      connection.onPartialTranscript = (text: string, interactionId: string) => {
-        this.graphExecutor.handlePartialTranscriptDelta(interactionId, text);
-      };
-    }
-
-    this.send(RealtimeEventFactory.sessionCreated(this.sessionManager.getSession().session));
-  }
-
-  /**
-   * Handle incoming WebSocket messages
-   */
-  async handleMessage(data: RawData): Promise<void> {
-    try {
-      const event = JSON.parse(data.toString()) as RT.ClientEvent;
-
-      // Handle these events immediately without queuing:
-
-      // 1. Cancellation - needs to stop ongoing response generation immediately
-      if (event.type === 'response.cancel') {
-        logger.info({
-          sessionId: this.sessionKey,
-          responseId: event.response_id,
-        }, `Cancelling response with id: ${event.response_id}`);
-        this.graphExecutor.cancelCurrentResponse('client_cancelled');
-        return;
-      }
-
-      // 2. Audio append - needs to flow continuously without blocking
-      if (event.type === 'input_audio_buffer.append') {
-        await this.audioHandler.handleInputAudioBufferAppend(event);
-        return;
-      }
-
-      // Add all other events to the queue to ensure sequential processing
-      this.addToQueue(async () => {
-        try {
-          switch (event.type) {
-            case 'session.update':
-              await this.sessionManager.updateSession(event);
-              break;
-
-            case 'input_audio_buffer.commit':
-              await this.audioHandler.handleInputAudioBufferCommit(event);
-              break;
-
-            case 'input_audio_buffer.clear':
-              await this.audioHandler.handleInputAudioBufferClear(event);
-              break;
-
-            case 'conversation.item.create':
-              await this.sessionManager.createConversationItem(event, this.audioHandler);
-              break;
-
-            case 'conversation.item.truncate':
-              await this.sessionManager.truncateConversationItem(event);
-              break;
-
-            case 'conversation.item.delete':
-              await this.sessionManager.deleteConversationItem(event);
-              break;
-
-            case 'conversation.item.retrieve':
-              await this.sessionManager.retrieveConversationItem(event);
-              break;
-
-            case 'response.create':
-              await this.graphExecutor.createResponse();
-              break;
-
-            default:
-              logger.warn({ eventType: (event as any).type, sessionId: this.sessionKey }, `Unknown event type: ${(event as any).type}`);
-          }
-        } catch (error) {
-          logger.error({ err: error, sessionId: this.sessionKey }, 'Error handling queued message');
-          this.send(
-            RealtimeEventFactory.error({
-              type: 'invalid_request_error',
-              message: error.message,
-            }),
-          );
-        }
-      });
-    } catch (error) {
-      logger.error({ err: error, sessionId: this.sessionKey }, 'Error parsing message');
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          message: 'Failed to parse message',
-        }),
-      );
-    }
-  }
-
-  /**
-   * Add task to processing queue
-   */
-  private addToQueue(task: () => Promise<void>): void {
-    this.processingQueue.push(task);
-    this.processQueue();
-  }
-
-  /**
-   * Process queued tasks
-   */
-  private async processQueue(): Promise<void> {
-    if (this.isProcessing) {
-      return;
-    }
-    this.isProcessing = true;
-    while (this.processingQueue.length > 0) {
-      const task = this.processingQueue.shift();
-      if (task) {
-        try {
-          await task();
-        } catch (error) {
-          logger.error({ err: error, sessionId: this.sessionKey }, 'Error processing task from queue');
-        }
-      }
-    }
-    this.isProcessing = false;
-  }
-}
diff --git a/realtime-service/src/components/realtime/realtime_session_manager.ts b/realtime-service/src/components/realtime/realtime_session_manager.ts
deleted file mode 100644
index aa46204..0000000
--- a/realtime-service/src/components/realtime/realtime_session_manager.ts
+++ /dev/null
@@ -1,508 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../../logger';
-import { formatSession, formatContext } from '../../log-helpers';
-import * as RT from '../../types/realtime';
-import { InworldApp } from '../app';
-import { RealtimeEventFactory } from './realtime_event_factory';
-import { Connection } from '../../types/index';
-import { getAssemblyAISettingsForEagerness } from '../../types/settings';
-import { RealtimeAudioHandler } from '../audio/realtime_audio_handler';
-
-export class RealtimeSessionManager {
-  realtimeSession: RT.RealtimeSession;
-  private sessionStartTime: number;
-
-  constructor(
-    private inworldApp: InworldApp,
-    private sessionKey: string,
-    private send: (data: RT.ServerEvent) => void,
-    sessionStartTime: number
-  ) {
-    this.sessionStartTime = sessionStartTime;
-    this.realtimeSession = this.createDefaultSession();
-  }
-
-  getSession(): RT.RealtimeSession {
-    return this.realtimeSession;
-  }
-
-
-  /**
-   * Create a default session configuration
-   */
-  private createDefaultSession(): RT.RealtimeSession {
-    const sessionId = uuidv4();
-
-    const connection = this.inworldApp.connections[this.sessionKey];
-    const instructions = connection?.state?.agent
-      ? `You are: "${connection.state.agent.name}". Your persona is: "${connection.state.agent.description}". Your motivation is: "${connection.state.agent.motivation}".`
-      : 'You are a helpful AI assistant.';
-
-    // Session expires in 15 minutes (900 seconds)
-    const expiresAt = Math.floor(Date.now() / 1000) + 900;
-
-    const defaultOutputModalities: ('text' | 'audio')[] = ['audio', 'text'];
-    
-    // Sync default to connection state
-    if (connection) {
-      connection.state.output_modalities = defaultOutputModalities;
-    }
-    
-    return {
-      id: sessionId,
-      session: {
-        type: 'realtime',
-        id: sessionId,
-        object: 'realtime.session',
-        model: this.inworldApp.llmModelName,
-        output_modalities: defaultOutputModalities,
-        instructions,
-        audio: {
-          input: {
-            format: {
-              type: 'audio/pcm',
-              rate: 24000,
-            },
-            transcription: null,
-            noise_reduction: null,
-            turn_detection: {
-              type: 'semantic_vad',
-              eagerness: 'medium',
-              create_response: true,
-              interrupt_response: true,
-            },
-          },
-          output: {
-            format: {
-              type: 'audio/pcm',
-              rate: 24000,
-            },
-            voice: this.inworldApp.voiceId,
-            speed: 1,
-          },
-        },
-        tools: [],
-        tool_choice: 'auto',
-        temperature: 0.8,
-        max_output_tokens: 'inf',
-        truncation: 'auto',
-        prompt: null,
-        tracing: null,
-        expires_at: expiresAt,
-        include: null,
-      },
-      conversationItems: [],
-      inputAudioBuffer: [],
-      currentResponse: null,
-      audioStartMs: 0,
-      currentContentStream: null,
-      currentTTSStream: null,
-    };
-  }
-
-  /**
-   * Handle session.update event
-   */
-  async updateSession(event: RT.SessionUpdateEvent): Promise<void> {
-    const sessionConfig = event.session;
-
-    // Deep merge session configuration
-    if (sessionConfig.output_modalities !== undefined) {
-      this.realtimeSession.session.output_modalities = sessionConfig.output_modalities;
-      
-      // Sync to connection state for easy access by sessionId
-      const connection = this.inworldApp.connections[this.sessionKey];
-      if (connection) {
-        connection.state.output_modalities = sessionConfig.output_modalities;
-        logger.info({
-          sessionId: this.sessionKey,
-          output_modalities: sessionConfig.output_modalities,
-          state_modalities: connection.state.output_modalities
-        }, `Updated connection.state.output_modalities`);
-      } else {
-        logger.warn({ sessionId: this.sessionKey }, `No connection found when updating output_modalities`);
-      }
-    }
-
-    if (sessionConfig.instructions !== undefined) {
-      this.realtimeSession.session.instructions = sessionConfig.instructions;
-
-      // Inject system instructions as the first message in the conversation state
-      const connection = this.inworldApp.connections[this.sessionKey];
-      if (connection && sessionConfig.instructions) {
-        // Check if there's already a system message at the start
-        const hasSystemMessage =
-          connection.state.messages.length > 0 &&
-          connection.state.messages[0].role === 'system';
-
-        if (hasSystemMessage) {
-          // Update existing system message
-          connection.state.messages[0].content = sessionConfig.instructions;
-          logger.info({ sessionId: this.sessionKey }, 'Updated system instructions');
-        } else {
-          // Insert new system message at the beginning
-          connection.state.messages.unshift({
-            id: 'system_instructions',
-            role: 'system',
-            content: sessionConfig.instructions,
-          });
-          logger.info({ sessionId: this.sessionKey }, 'Injected system instructions');
-        }
-      }
-    }
-
-    if (sessionConfig.audio) {
-      // Merge audio input configuration
-      if (sessionConfig.audio.input) {
-        if (sessionConfig.audio.input.format) {
-          this.realtimeSession.session.audio.input.format = {
-            ...this.realtimeSession.session.audio.input.format,
-            ...sessionConfig.audio.input.format,
-          };
-        }
-        if (sessionConfig.audio.input.transcription !== undefined) {
-          this.realtimeSession.session.audio.input.transcription = sessionConfig.audio.input.transcription;
-        }
-        if (sessionConfig.audio.input.noise_reduction !== undefined) {
-          this.realtimeSession.session.audio.input.noise_reduction = sessionConfig.audio.input.noise_reduction;
-        }
-        if (sessionConfig.audio.input.turn_detection !== undefined) {
-          if (sessionConfig.audio.input.turn_detection === null) {
-            this.realtimeSession.session.audio.input.turn_detection = null;
-          } else {
-            this.realtimeSession.session.audio.input.turn_detection = {
-              ...this.realtimeSession.session.audio.input.turn_detection,
-              ...sessionConfig.audio.input.turn_detection,
-            };
-            
-            // Handle semantic_vad eagerness settings
-            if (sessionConfig.audio.input.turn_detection.type === 'semantic_vad') {
-              const eagerness = sessionConfig.audio.input.turn_detection.eagerness;
-              if (eagerness && eagerness !== 'auto') {
-                const connection = this.inworldApp.connections[this.sessionKey];
-                if (connection) {
-                  const normalizedEagerness = eagerness as 'low' | 'medium' | 'high';
-                  connection.state.eagerness = normalizedEagerness;
-                  logger.info({ sessionId: this.sessionKey, eagerness }, `Updated eagerness to ${eagerness}`);
-
-                  // Dynamically update AssemblyAI turn detection settings on the active graph
-                  const assemblyAINode = this.inworldApp.graphWithAudioInput?.assemblyAINode;
-                  if (assemblyAINode) {
-                    const assemblySettings = getAssemblyAISettingsForEagerness(normalizedEagerness);
-                    // Extract only the numeric settings for updateTurnDetectionSettings
-                    const { endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence } = assemblySettings;
-                    logger.info({ sessionId: this.sessionKey, endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence }, `Applying eagerness settings: threshold=${endOfTurnConfidenceThreshold}`);
-                    assemblyAINode.updateTurnDetectionSettings(
-                        this.sessionKey,
-                        { endOfTurnConfidenceThreshold, minEndOfTurnSilenceWhenConfident, maxTurnSilence }
-                    )
-                  } else {
-                    logger.warn({ sessionId: this.sessionKey }, 'AssemblyAI node not found, settings will apply on next audio input');
-                    this.send(
-                        RealtimeEventFactory.error({
-                          type: 'invalid_request_error',
-                          code: 'no_STT_session',
-                          message: `Server did not find active STT connection. Turning on Mic to start audio stream input session.`,
-                          event_id: event.event_id,
-                        }),
-                    );
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // Merge audio output configuration
-      if (sessionConfig.audio.output) {
-        if (sessionConfig.audio.output.format) {
-          this.realtimeSession.session.audio.output.format = {
-            ...this.realtimeSession.session.audio.output.format,
-            ...sessionConfig.audio.output.format,
-          };
-        }
-        if (sessionConfig.audio.output.voice !== undefined) {
-          this.realtimeSession.session.audio.output.voice = sessionConfig.audio.output.voice;
-
-          // Store voice in connection state for TTS node
-          const connection = this.inworldApp.connections[this.sessionKey];
-          if (connection) {
-            connection.state.voiceId = sessionConfig.audio.output.voice;
-            logger.info({ sessionId: this.sessionKey, voice: sessionConfig.audio.output.voice }, `Updated TTS voice to ${sessionConfig.audio.output.voice}`);
-          }
-        }
-        if (sessionConfig.audio.output.speed !== undefined) {
-          this.realtimeSession.session.audio.output.speed = sessionConfig.audio.output.speed;
-        }
-      }
-    }
-
-    if (sessionConfig.tools !== undefined) {
-      this.realtimeSession.session.tools = sessionConfig.tools;
-
-      // Update connection state with tools
-      const connection = this.inworldApp.connections[this.sessionKey];
-      if (connection) {
-        connection.state.tools = sessionConfig.tools;
-      }
-    }
-
-    if (sessionConfig.tool_choice !== undefined) {
-      this.realtimeSession.session.tool_choice = sessionConfig.tool_choice;
-
-      // Update connection state with toolChoice
-      const connection = this.inworldApp.connections[this.sessionKey];
-      if (connection) {
-        connection.state.toolChoice = sessionConfig.tool_choice;
-      }
-    }
-
-    if (sessionConfig.temperature !== undefined) {
-      this.realtimeSession.session.temperature = sessionConfig.temperature;
-    }
-
-    if (sessionConfig.max_output_tokens !== undefined) {
-      this.realtimeSession.session.max_output_tokens = sessionConfig.max_output_tokens;
-    }
-
-    if (sessionConfig.truncation !== undefined) {
-      this.realtimeSession.session.truncation = sessionConfig.truncation;
-    }
-
-    if (sessionConfig.prompt !== undefined) {
-      this.realtimeSession.session.prompt = sessionConfig.prompt;
-    }
-
-    if (sessionConfig.tracing !== undefined) {
-      this.realtimeSession.session.tracing = sessionConfig.tracing;
-    }
-
-    if (sessionConfig.include !== undefined) {
-      this.realtimeSession.session.include = sessionConfig.include;
-    }
-
-    // Send session.updated event
-    this.send(RealtimeEventFactory.sessionUpdated(this.realtimeSession.session));
-  }
-
-  /**
-   * Handle conversation.item.create event
-   */
-  async createConversationItem(
-    event: RT.ConversationItemCreateEvent,
-    audioHandler?: RealtimeAudioHandler,
-  ): Promise<void> {
-    const item = {
-      ...event.item,
-      id: event.item.id || uuidv4(),
-      object: 'realtime.item' as const,
-      status: event.item.status || ('completed' as const),
-    };
-
-    this.realtimeSession.conversationItems.push(item);
-    this.send(
-      RealtimeEventFactory.conversationItemAdded(item, event.previous_item_id),
-    );
-    this.send(
-      RealtimeEventFactory.conversationItemDone(item, event.previous_item_id),
-    );
-    
-    // Add to conversation state so LLM is aware of this item
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (connection) {
-      // Handle different item types
-      if (item.type === 'function_call_output') {
-        // Function call output received
-        const functionOutputItem = item as RT.FunctionCallOutputItem;
-        logger.info({
-          sessionId: this.sessionKey,
-          call_id: functionOutputItem.call_id,
-          output: functionOutputItem.output,
-        }, 'Function output received');
-        
-        // Add a system message to inform the LLM that the function was executed
-        // The Inworld SDK/Groq combo doesn't properly support 'tool' role with tool_call_id
-        // So we use a system message to provide context about the function execution
-        connection.state.messages.push({
-          role: 'system',
-          content: `[SYSTEM] Function executed. Result: ${functionOutputItem.output}`,
-          id: item.id,
-        });
-        
-        logger.info({ sessionId: this.sessionKey }, 'Added function execution result to conversation');
-      } else if (item.type === 'message') {
-        // Handle message items
-        const messageItem = item as RT.MessageItem;
-        if (messageItem.content && messageItem.content.length > 0) {
-          const content = messageItem.content[0];
-          let textContent = '';
-          
-          if (content.type === 'input_text') {
-            textContent = content.text || '';
-          } else if (content.type === 'text') {
-            textContent = content.text || '';
-          } else if (content.type === 'input_audio') {
-            // Audio inputs should already be handled by STT
-            return;
-          }
-          
-          if (textContent) {
-            logger.info({
-              sessionId: this.sessionKey,
-              role: messageItem.role,
-              contentPreview: textContent.substring(0, 100),
-            }, `Adding ${messageItem.role} message: ${textContent.substring(0, 50)}...`);
-            // We don't need to call connection.state.messages.push here. That's handled in the graph's input node
-          }
-
-          // If it's a text input, push it to the audio graph
-          if (content.type === 'input_text' && content.text && audioHandler) {
-            await audioHandler.handleTextInput(content.text);
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Handle conversation.item.truncate event
-   */
-  async truncateConversationItem(
-    event: RT.ConversationItemTruncateEvent,
-  ): Promise<void> {
-    // Find the item
-    const item = this.realtimeSession.conversationItems.find(
-      (i) => i.id === event.item_id,
-    );
-
-    if (!item) {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          code: 'item_not_found',
-          message: `Item with id ${event.item_id} not found`,
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    // Only assistant message items can be truncated
-    if (item.role !== 'assistant') {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          code: 'invalid_item_type',
-          message: 'Only assistant message items can be truncated',
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    // Truncate the content part at the specified index
-    if (item.content && item.content[event.content_index]) {
-      const contentPart = item.content[event.content_index];
-      
-      // If it's an audio content part, truncate the audio and remove transcript
-      if (contentPart.type === 'audio' && contentPart.audio) {
-        // Note: In a real implementation, we would need to:
-        // 1. Decode the base64 audio
-        // 2. Calculate the number of samples to keep based on audio_end_ms
-        // 3. Truncate the audio data
-        // 4. Re-encode to base64
-        // For now, we'll just remove the transcript to ensure no text is in context that hasn't been heard
-        delete contentPart.transcript;
-        
-        // In a full implementation, we would also truncate the audio data itself
-        logger.info({
-          sessionId: this.sessionKey,
-          itemId: event.item_id,
-          audioEndMs: event.audio_end_ms,
-          contentIndex: event.content_index,
-        }, `Truncating item ${event.item_id} at ${event.audio_end_ms}ms`);
-      }
-    }
-
-    // Send the truncated event
-    this.send(
-      RealtimeEventFactory.conversationItemTruncated(
-        event.item_id,
-        event.content_index,
-        event.audio_end_ms,
-      ),
-    );
-  }
-
-  /**
-   * Handle conversation.item.delete event
-   */
-  async deleteConversationItem(
-    event: RT.ConversationItemDeleteEvent,
-  ): Promise<void> {
-    const index = this.realtimeSession.conversationItems.findIndex(
-      (i) => i.id === event.item_id,
-    );
-
-    if (index === -1) {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          code: 'item_not_found',
-          message: `Item with id ${event.item_id} not found`,
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    // Remove the item from conversation history
-    this.realtimeSession.conversationItems.splice(index, 1);
-
-    // Also remove from connection.state.messages so the graph doesn't see it
-    const connection = this.inworldApp.connections[this.sessionKey];
-    if (connection?.state?.messages) {
-      const messageIndex = connection.state.messages.findIndex(
-        (m) => m.id === event.item_id,
-      );
-      if (messageIndex !== -1) {
-        connection.state.messages.splice(messageIndex, 1);
-      }
-    }
-
-    // Send the deleted event
-    this.send(
-      RealtimeEventFactory.conversationItemDeleted(event.item_id),
-    );
-  }
-
-  /**
-   * Handle conversation.item.retrieve event
-   */
-  async retrieveConversationItem(
-    event: RT.ConversationItemRetrieveEvent,
-  ): Promise<void> {
-    const item = this.realtimeSession.conversationItems.find(
-      (i) => i.id === event.item_id,
-    );
-
-    if (!item) {
-      this.send(
-        RealtimeEventFactory.error({
-          type: 'invalid_request_error',
-          code: 'item_not_found',
-          message: `Item with id ${event.item_id} not found`,
-          event_id: event.event_id,
-        }),
-      );
-      return;
-    }
-
-    // Send the retrieved item
-    this.send(
-      RealtimeEventFactory.conversationItemRetrieved(item),
-    );
-  }
-}
-
diff --git a/realtime-service/src/components/runtime_app_manager.ts b/realtime-service/src/components/runtime_app_manager.ts
deleted file mode 100644
index 341c76e..0000000
--- a/realtime-service/src/components/runtime_app_manager.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-import { stopInworldRuntime } from '@inworld/runtime';
-import logger from '../logger';
-import { InworldApp } from './app';
-import { Connection } from '../types/index';
-
-export interface AppConfig {
-  graphId?: string;
-  llmModelName?: string;
-  llmProvider?: string;
-  voiceId?: string;
-  ttsModelId?: string;
-  graphVisualizationEnabled?: boolean;
-  assemblyAIApiKey?: string;
-  useMocks?: boolean;
-}
-
-export interface InworldAppConfig extends AppConfig {
-  sharedConnections?: { [sessionId: string]: Connection };
-}
-
-/**
- * Helper to merge string config values with fallback chain
- */
-function getStringConfig(
-  configValue: string | undefined,
-  defaultValue: string | undefined,
-  envVar?: string | undefined,
-  fallback: string = '',
-): string {
-  return configValue || defaultValue || envVar || fallback;
-}
-
-/**
- * Helper to merge boolean config values with fallback chain
- * Uses nullish coalescing to preserve false values
- */
-function getBooleanConfig(
-  configValue: boolean | undefined,
-  defaultValue: boolean | undefined,
-  envVar: string | undefined,
-  fallback: boolean,
-): boolean {
-  if (configValue !== undefined) return configValue;
-  if (defaultValue !== undefined) return defaultValue;
-  if (envVar !== undefined && envVar.trim() !== '') {
-    return envVar.toLowerCase().trim() === 'true';
-  }
-  return fallback;
-}
-
-/**
- * InworldRuntimeAppManager manages a single InworldApp instance.
- * The graph supports multitenancy natively, so we only need one instance.
- */
-export class InworldRuntimeAppManager {
-  private app: InworldApp | null = null;
-  private defaultConfig: Partial<AppConfig>;
-  private initPromise: Promise<InworldApp> | null = null;
-
-  // Shared connections map for all sessions
-  private sharedConnections: { [sessionId: string]: Connection } = {};
-
-  constructor(defaultConfig?: Partial<AppConfig>) {
-    this.defaultConfig = defaultConfig || {};
-  }
-
-  /**
-   * Get the singleton InworldApp instance, creating it if needed.
-   * Uses lazy initialization with proper handling of concurrent calls.
-   */
-  async getApp(configOverrides?: Partial<AppConfig>): Promise<InworldApp> {
-    // Return existing app if already initialized
-    if (this.app) {
-      return this.app;
-    }
-
-    // If initialization is in progress, wait for it
-    if (this.initPromise) {
-      return this.initPromise;
-    }
-
-    // Start initialization
-    this.initPromise = this.createApp(configOverrides);
-
-    try {
-      this.app = await this.initPromise;
-      return this.app;
-    } finally {
-      this.initPromise = null;
-    }
-  }
-
-  private async createApp(configOverrides?: Partial<AppConfig>): Promise<InworldApp> {
-    logger.info('Creating InworldApp instance');
-
-    const finalConfig: InworldAppConfig = {
-      graphId: getStringConfig(configOverrides?.graphId, this.defaultConfig.graphId, undefined),
-      llmModelName: getStringConfig(configOverrides?.llmModelName, this.defaultConfig.llmModelName),
-      llmProvider: getStringConfig(configOverrides?.llmProvider, this.defaultConfig.llmProvider),
-      voiceId: getStringConfig(configOverrides?.voiceId, this.defaultConfig.voiceId),
-      ttsModelId: getStringConfig(configOverrides?.ttsModelId, this.defaultConfig.ttsModelId),
-      graphVisualizationEnabled: getBooleanConfig(configOverrides?.graphVisualizationEnabled, this.defaultConfig.graphVisualizationEnabled, process.env.GRAPH_VISUALIZATION_ENABLED, false),
-      assemblyAIApiKey: getStringConfig(configOverrides?.assemblyAIApiKey, this.defaultConfig.assemblyAIApiKey, process.env.ASSEMBLYAI_API_KEY),
-      useMocks: getBooleanConfig(configOverrides?.useMocks, this.defaultConfig.useMocks, process.env.USE_MOCKS, false),
-      sharedConnections: this.sharedConnections,
-    };
-
-    // Validate required config
-    if (!finalConfig.assemblyAIApiKey) {
-      const error = new Error('Missing AssemblyAI API key');
-      logger.error({ err: error }, 'Missing AssemblyAI API key');
-      throw error;
-    }
-
-    const app = await InworldApp.create(finalConfig);
-    logger.info('InworldApp initialized successfully');
-    return app;
-  }
-
-  /**
-   * Check if the app has been initialized
-   */
-  isInitialized(): boolean {
-    return this.app !== null;
-  }
-
-  /**
-   * Shutdown the app and clean up resources
-   */
-  async shutdown(): Promise<void> {
-    if (this.app) {
-      logger.info('Shutting down InworldApp');
-      await this.app.shutdown();
-      this.app = null;
-    }
-
-    // Stop the global Inworld runtime
-    stopInworldRuntime();
-  }
-}
diff --git a/realtime-service/src/config.ts b/realtime-service/src/config.ts
deleted file mode 100644
index 7bbba6f..0000000
--- a/realtime-service/src/config.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-// Audio Configuration Constants
-export const TTS_SAMPLE_RATE = 24000; // Sample rate for TTS output
-export const INPUT_SAMPLE_RATE = 16000; // Sample rate for STT input (Assembly.AI)
-
-// Server Configuration
-export const WS_APP_PORT = 4000; // WebSocket server port
-
-// LLM Model Configuration
-export const DEFAULT_LLM_MODEL_NAME = process.env.LLM_MODEL_NAME || 'meta-llama/Llama-3.1-70b-Instruct';
-export const DEFAULT_LLM_PROVIDER = process.env.LLM_PROVIDER || 'inworld';
-
-// Voice and TTS Configuration
-export const DEFAULT_VOICE_ID = process.env.VOICE_ID || 'Dennis';
-export const DEFAULT_TTS_MODEL_ID = process.env.TTS_MODEL_ID || 'inworld-tts-1';
-
diff --git a/realtime-service/src/helpers.ts b/realtime-service/src/helpers.ts
deleted file mode 100644
index 855febb..0000000
--- a/realtime-service/src/helpers.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import logger from './logger';
-import { DEFAULT_LLM_MODEL_NAME, DEFAULT_LLM_PROVIDER, DEFAULT_VOICE_ID, DEFAULT_TTS_MODEL_ID } from './config';
-
-export const parseEnvironmentVariables = () => {
-  if (!process.env.INWORLD_API_KEY) {
-    throw new Error('INWORLD_API_KEY env variable is required');
-  }
-
-  // Assembly.AI is now the only STT provider for audio input
-  if (!process.env.ASSEMBLYAI_API_KEY) {
-    throw new Error('ASSEMBLYAI_API_KEY env variable is required');
-  }
-
-  logger.info('STT Service: Assembly.AI (only supported provider)');
-
-  return {
-    apiKey: process.env.INWORLD_API_KEY,
-    llmModelName: DEFAULT_LLM_MODEL_NAME,
-    llmProvider: DEFAULT_LLM_PROVIDER,
-    voiceId: DEFAULT_VOICE_ID,
-    ttsModelId: DEFAULT_TTS_MODEL_ID,
-    // Because the env variable is optional and it's a string, we need to convert it to a boolean safely
-    graphVisualizationEnabled:
-      (process.env.GRAPH_VISUALIZATION_ENABLED || '').toLowerCase().trim() ===
-      'true',
-    assemblyAIApiKey: process.env.ASSEMBLYAI_API_KEY,
-    appName: process.env.APP_NAME || 'realtime-service',
-    appVersion: process.env.APP_VERSION || '1.0.0',
-  };
-};
-
-/**
- * Safely aborts a stream with proper error handling and logging.
- * Handles both regular streams with abort() method and ContentStreams with napiStream.
- * 
- * @param stream The stream to abort (must have an abort method or napiStream with abort method)
- * @param streamName Descriptive name for the stream (for logging)
- * @param sessionId Session ID associated with the stream (for logging)
- * @param context Optional context message for logging (e.g., 'on close', 'due to cancellation')
- */
-export function abortStream(
-  stream: any | undefined,
-  streamName: string,
-  sessionId: string,
-  context: string = ''
-): void {
-  if (!stream) {
-    return;
-  }
-
-  const logContext = context ? ` ${context}` : '';
-  logger.debug({ sessionId }, `Aborting ${streamName}${logContext}`);
-
-  try {
-    if (typeof stream.abort === 'function') {
-      stream.abort();
-    } else if (stream.napiStream && typeof stream.napiStream.abort === 'function') {
-      // ContentStream doesn't have an abort() method, but we can try to abort the underlying napiStream
-      stream.napiStream.abort();
-    }
-  } catch (error) {
-    logger.error({ error, sessionId }, `Error aborting ${streamName}`);
-  }
-}
-
diff --git a/realtime-service/src/index.ts b/realtime-service/src/index.ts
deleted file mode 100644
index 55d24bc..0000000
--- a/realtime-service/src/index.ts
+++ /dev/null
@@ -1,319 +0,0 @@
-import 'dotenv/config';
-
-import {InworldError} from '@inworld/runtime/common';
-import {initTelemetry} from '@inworld/runtime/telemetry';
-import cors from 'cors';
-import express from 'express';
-import http from 'http';
-import {createServer} from 'http';
-import client from 'prom-client';
-import {parse} from 'url';
-import {RawData, WebSocketServer} from 'ws';
-
-import {RealtimeMessageHandler} from './components/realtime/realtime_message_handler';
-import {InworldRuntimeAppManager} from './components/runtime_app_manager';
-import {WS_APP_PORT} from './config';
-import {abortStream, parseEnvironmentVariables} from './helpers';
-import {formatContext, formatError, formatSession, formatWorkspace} from './log-helpers';
-import logger from './logger';
-
-const METRICS_PORT = 9000;
-const register = new client.Registry();
-register.setDefaultLabels({app: 'realtime-service'});
-
-// Enable collection of default metrics
-client.collectDefaultMetrics({register});
-
-const wsConnectionCounter = new client.Gauge({
-  name: 'websocket_connections_total',
-  help: 'Total number of active WebSocket connections',
-  registers: [register],
-});
-
-const app = express();
-const server = createServer(app);
-const webSocket = new WebSocketServer({noServer: true});
-
-const metricsApp = express();
-const metricsServer = http.createServer(metricsApp);
-
-app.use(cors());
-app.use(express.json());
-app.use(express.static('frontend'));
-
-// InworldRuntimeAppManager manages a single graph instance
-// The graph supports multitenancy natively via API key in execute method
-const env = parseEnvironmentVariables();
-const inworldRuntimeAppManager = new InworldRuntimeAppManager({
-  llmModelName: env.llmModelName,
-  llmProvider: env.llmProvider,
-  voiceId: env.voiceId,
-  ttsModelId: env.ttsModelId,
-  graphVisualizationEnabled: env.graphVisualizationEnabled,
-  assemblyAIApiKey: env.assemblyAIApiKey,
-});
-
-initTelemetry({
-  apiKey: env.apiKey,
-  appName: env.appName,
-  appVersion: env.appVersion,
-});
-
-metricsApp.get('/metrics', async (req, res) => {
-  try {
-    res.set('Content-Type', register.contentType);
-    res.end(await register.metrics());
-  } catch (ex) {
-    logger.error({error: ex}, `Error serving metrics${formatError(ex)}`);
-    res.status(500).end('Internal Server Error');
-  }
-});
-
-app.get('/health', (req, res) => {
-  res.status(200).send('OK');
-});
-
-/**
- * Extracts the Inworld API key from the WebSocket protocol header.
- * The key is embedded in the sec-websocket-protocol header with a 'basic_'
- * prefix. This function removes the prefix and reconstructs any missing base64
- * padding.
- */
-function extractInworldApiKey(headers: http.IncomingHttpHeaders): string|
-    undefined {
-  const wsProtocolHeader = headers['sec-websocket-protocol'] as string;
-  if (!wsProtocolHeader) {
-    return undefined;
-  }
-
-  // The protocol header may contain comma-separated values, look for basic_
-  // prefix
-  const protocols = wsProtocolHeader.split(',').map(p => p.trim());
-  for (const protocol of protocols) {
-    if (protocol.startsWith('basic_')) {
-      let base64Key = protocol.substring(
-          6);  // Remove 'basic_' prefix to get base64 credentials
-
-      // Reconstruct missing padding = symbols (sender cuts trailing = symbols)
-      // Base64 strings should be a multiple of 4 characters in length
-      const paddingNeeded = (4 - (base64Key.length % 4)) % 4;
-      if (paddingNeeded > 0) {
-        base64Key += '='.repeat(paddingNeeded);
-      }
-      return base64Key;
-    }
-  }
-
-  return undefined;
-}
-
-webSocket.on('connection', async (ws, request) => {
-  wsConnectionCounter.inc(1);
-  const workspaceId = (request.headers['workspace-id'] as string) ||
-      process.env.WORKSPACE_ID || 'default';
-
-  try {
-    logger.info(
-        {workspaceId},
-        `WebSocket connection received ${formatWorkspace(workspaceId)}`);
-
-    // Extract the Inworld API key from sec-websocket-protocol header
-    const inworldApiKey = extractInworldApiKey(request.headers);
-
-    const {query} = parse(request.url!, true);
-    const sessionId = query.key?.toString();
-
-    logger.info(
-        {sessionId, workspaceId},
-        `WebSocket connection established ${
-            formatContext(sessionId, workspaceId)}`);
-
-    if (!sessionId) {
-      logger.error(
-          {workspaceId},
-          `WebSocket connection rejected ${
-              formatWorkspace(workspaceId)}: no session key provided`);
-      ws.close(1008, 'No session key provided');
-      return;
-    }
-
-    // Get the singleton InworldApp instance
-    const inworldApp = await inworldRuntimeAppManager.getApp();
-
-    // Create session on-the-fly if it doesn't exist
-    if (!inworldApp.connections?.[sessionId]) {
-      logger.info(
-          {sessionId, workspaceId},
-          `Creating new session ${formatContext(sessionId, workspaceId)}`);
-      // Create a minimal connection for realtime protocol
-      // The session will be fully configured via session.update events
-      inworldApp.connections[sessionId] = {
-        workspaceId,
-        state: {
-          interactionId: '',  // Will be set by graph nodes
-          messages: [],
-          agent: null,
-          userName: 'User',
-        },
-        apiKey: inworldApiKey || '',
-        ws: null,
-      };
-    }
-
-    inworldApp.connections[sessionId].ws =
-        inworldApp.connections[sessionId].ws ?? ws;
-
-    ws.on('error', (error) => {
-      logger.error(
-          {error, sessionId, workspaceId},
-          `WebSocket error ${formatContext(sessionId, workspaceId)}${
-              formatError(error)}`);
-    });
-
-    ws.on('close', async (code, reason) => {
-      logger.info(
-          {sessionId, workspaceId, code, reason: reason.toString()},
-          `WebSocket closed ${formatContext(sessionId, workspaceId)} [code:${
-              code}] [reason:${reason.toString()}]`);
-      wsConnectionCounter.dec(1);
-
-      const connection = inworldApp.connections[sessionId];
-      if (connection) {
-        // Step 1: Abort any active graph executions FIRST
-        abortStream(
-            connection.currentAudioExecutionStream, 'audio execution stream',
-            sessionId, 'on close');
-        connection.currentAudioExecutionStream = undefined;
-
-        // Step 2: Clean up multimodal stream if it exists
-        if (connection.multimodalStreamManager) {
-          logger.info(
-              {sessionId},
-              `Ending multimodal stream ${
-                  formatSession(sessionId)} due to WebSocket close`);
-          connection.multimodalStreamManager.end();
-          connection.multimodalStreamManager = undefined;
-        }
-
-        // Step 3: Clean up audio graph execution reference
-        if (connection.currentAudioGraphExecution) {
-          connection.currentAudioGraphExecution = undefined;
-        }
-      }
-
-      // Clean up AssemblyAI STT session if it exists
-      const assemblyAINode = inworldApp.graphWithAudioInput?.assemblyAINode;
-      if (assemblyAINode) {
-        try {
-          await assemblyAINode.closeSession(sessionId);
-        } catch (error) {
-          logger.error(
-              {error, sessionId, workspaceId},
-              `Error during closing Assembly Session ${
-                  formatContext(sessionId, workspaceId)}${formatError(error)}`);
-        }
-      }
-
-      // Clean up connection
-      inworldApp.removeSession(sessionId);
-      logger.info(`[Session ${sessionId}] Session removed and resources cleaned up`);
-    });
-
-    // Use OpenAI Realtime API protocol
-    const realtimeHandler = new RealtimeMessageHandler(
-        inworldApp,
-        sessionId,
-        (data: any) => ws.send(JSON.stringify(data)),
-    );
-
-    // Initialize session and send session.created event
-    logger.info(
-        {sessionId, workspaceId},
-        `Initializing realtime session ${
-            formatContext(sessionId, workspaceId)}`);
-    await realtimeHandler.initialize();
-    logger.info(
-        {sessionId, workspaceId},
-        `Realtime session initialized successfully ${
-            formatContext(sessionId, workspaceId)}`);
-
-    ws.on('message', (data: RawData) => realtimeHandler.handleMessage(data));
-  } catch (error) {
-    logger.error(
-        {error, workspaceId},
-        `WebSocket connection error ${formatWorkspace(workspaceId)}${
-            formatError(error)}`);
-    ws.close(1011, 'Internal server error');
-  }
-});
-
-server.on('upgrade', async (request, socket, head) => {
-  const {pathname, query} = parse(request.url!, true);
-
-  if (pathname === '/session') {
-    const authToken = process.env.AUTH_TOKEN;
-
-    // Validate token if configured
-    if (authToken) {
-      const providedToken = query?.token?.toString();
-
-      if (!providedToken || providedToken !== authToken) {
-        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-        socket.destroy();
-        return;
-      }
-    }
-
-    webSocket.handleUpgrade(request, socket, head, (ws) => {
-      webSocket.emit('connection', ws, request);
-    });
-  } else {
-    socket.destroy();
-  }
-});
-
-server.listen(WS_APP_PORT, () => {
-  logger.info(
-      {port: WS_APP_PORT},
-      `Application Server listening on port ${WS_APP_PORT}`);
-  logger.info('InworldApp will be created on first connection');
-});
-
-metricsServer.listen(METRICS_PORT, () => {
-  logger.info(
-      {port: METRICS_PORT}, `Metrics Server listening on port ${METRICS_PORT}`);
-});
-
-function done() {
-  logger.info('Server is closing');
-
-  // Handle the async shutdown properly
-  inworldRuntimeAppManager.shutdown()
-      .then(() => {
-        metricsServer.close(() => {
-          logger.info('Metrics server closed');
-          process.exit(0);
-        });
-      })
-      .catch((err) => {
-        logger.error({error: err}, `Error during shutdown${formatError(err)}`);
-        process.exit(1);
-      });
-}
-
-process.on('SIGINT', done);
-process.on('SIGTERM', done);
-process.on('SIGUSR2', done);
-process.on('unhandledRejection', (err: unknown) => {
-  if (err instanceof InworldError) {
-    logger.error(
-        {
-          message: err.message,
-          context: err.context,
-        },
-        `Inworld Error - unhandled rejection${formatError(err)}`);
-  } else {
-    logger.error({error: err}, `Unhandled rejection${formatError(err)}`);
-  }
-  process.exit(1);
-});
diff --git a/realtime-service/src/log-helpers.ts b/realtime-service/src/log-helpers.ts
deleted file mode 100644
index 074f8d9..0000000
--- a/realtime-service/src/log-helpers.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * Helper utilities for creating readable log messages with key context
- * 
- * These helpers make it easy to include important information in both:
- * 1. The message text (visible at a glance)
- * 2. Structured fields (for querying/filtering)
- */
-
-/**
- * Format a session context tag for log messages
- * Usage: `Something happened ${formatSession(sessionId)}`
- */
-export function formatSession(sessionId: string | undefined): string {
-  return sessionId ? `[session:${sessionId}]` : '';
-}
-
-/**
- * Format a workspace context tag for log messages
- * Usage: `Something happened ${formatWorkspace(workspaceId)}`
- */
-export function formatWorkspace(workspaceId: string | undefined): string {
-  return workspaceId ? `[workspace:${workspaceId}]` : '';
-}
-
-/**
- * Format an interaction context tag for log messages
- * Usage: `Something happened ${formatInteraction(interactionId)}`
- */
-export function formatInteraction(interactionId: string | undefined): string {
-  return interactionId ? `[interaction:${interactionId}]` : '';
-}
-
-/**
- * Format a duration in milliseconds
- * Usage: `Completed ${formatDuration(elapsed)}`
- */
-export function formatDuration(ms: number | undefined): string {
-  return ms !== undefined ? `[duration:${ms}ms]` : '';
-}
-
-/**
- * Format an error message
- * Usage: `Failed ${formatError(error)}`
- */
-export function formatError(error: unknown): string {
-  if (error instanceof Error) {
-    return `: ${error.message}`;
-  }
-  return error ? `: ${String(error)}` : '';
-}
-
-/**
- * Combine session and workspace tags
- * Usage: `Something happened ${formatContext(sessionId, workspaceId)}`
- */
-export function formatContext(
-  sessionId?: string,
-  workspaceId?: string,
-  interactionId?: string
-): string {
-  const parts = [
-    formatSession(sessionId),
-    formatWorkspace(workspaceId),
-    formatInteraction(interactionId),
-  ].filter(Boolean);
-  
-  return parts.join(' ');
-}
-
-/**
- * Example usage:
- * 
- * logger.info(
- *   { sessionId, workspaceId },
- *   `WebSocket connected ${formatContext(sessionId, workspaceId)}`
- * );
- * 
- * logger.error(
- *   { error, sessionId, operation },
- *   `Operation failed ${formatSession(sessionId)}${formatError(error)}`
- * );
- * 
- * logger.info(
- *   { sessionId, duration },
- *   `Request completed ${formatSession(sessionId)} ${formatDuration(duration)}`
- * );
- */
-
diff --git a/realtime-service/src/logger.ts b/realtime-service/src/logger.ts
deleted file mode 100644
index 7d20f50..0000000
--- a/realtime-service/src/logger.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import pino from 'pino';
-
-/**
- * Logger configuration for Google Cloud Logging compatibility
- * 
- * DEFAULT: JSON logs formatted for Cloud Logging (production-ready)
- * OPTIONAL: Pretty-print for local development
- * 
- * Each log entry is a single JSON object, preventing multi-line splits in Cloud Logging
- * 
- * Environment variables:
- * - REALTIME_LOG_LEVEL: 'debug', 'info', 'warn', 'error' (default: 'info')
- * - REALTIME_LOG_PRETTY: '1' to enable pretty logs locally (default: '0' = JSON)
- * 
- * Examples:
- *   npm start                              # JSON logs (default, cloud-ready)
- *   REALTIME_LOG_PRETTY=1 npm start        # Pretty logs (local dev)
- *   REALTIME_LOG_LEVEL=debug npm start     # JSON with debug level
- */
-const usePretty = process.env.REALTIME_LOG_PRETTY === '1';
-
-const logger = pino({
-  level: process.env.REALTIME_LOG_LEVEL || 'info',
-
-  // Use pretty print locally (unless LOG_PRETTY=0), JSON in production
-  transport: usePretty ? {
-    target: 'pino-pretty',
-    options: {
-      colorize: true,
-      translateTime: 'HH:MM:ss.l', // Include milliseconds for debugging
-      ignore: 'pid,hostname,service,version',
-      // Show message and structured fields in a compact format
-      messageFormat: '{levelLabel} {msg}',
-      // Show structured fields in compact single-line format
-      singleLine: true,
-      // Limit object depth to avoid huge logs
-      depth: 3,
-    }
-  } : undefined,
-
-  // Add common fields to all logs
-  base: {
-    service: 'realtime-service',
-    version: process.env.APP_VERSION || 'unknown',
-  },
-
-  // Format timestamps for Cloud Logging
-  timestamp: pino.stdTimeFunctions.isoTime,
-
-  // Map Pino levels to Cloud Logging severity
-  formatters: {
-    level: (label: string) => {
-      return { severity: label.toUpperCase() };
-    },
-  },
-
-  // Serialize errors properly
-  serializers: {
-    error: pino.stdSerializers.err,
-    req: pino.stdSerializers.req,
-    res: pino.stdSerializers.res,
-  },
-});
-
-export default logger;
-
diff --git a/realtime-service/src/package-lock.json b/realtime-service/src/package-lock.json
deleted file mode 100644
index 3d3144e..0000000
--- a/realtime-service/src/package-lock.json
+++ /dev/null
@@ -1,3273 +0,0 @@
-{
-  "name": "server",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "server",
-      "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
-      "dependencies": {
-        "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
-        "cors": "^2.8.5",
-        "dotenv": "^16.4.7",
-        "express": "^5.1.0",
-        "express-validator": "^7.2.1",
-        "groq-sdk": "^0.7.0",
-        "pino": "^9.14.0",
-        "pino-pretty": "^13.1.2",
-        "prom-client": "^15.1.3",
-        "uuid": "^11.1.0",
-        "wav-encoder": "^1.3.0",
-        "ws": "^8.18.1",
-        "zod": "^4.1.13"
-      },
-      "devDependencies": {
-        "@types/cors": "^2.8.17",
-        "@types/express": "^5.0.1",
-        "@types/express-validator": "^3.0.0",
-        "@types/node": "^22.14.0",
-        "@types/ws": "^8.18.1",
-        "nodemon": "^3.1.9",
-        "ts-node": "^10.9.2",
-        "tsconfig-paths": "^4.2.0",
-        "typescript": "^5.8.3"
-      }
-    },
-    "node_modules/@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
-      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@inworld/runtime": {
-      "version": "0.9.0-rc.13",
-      "resolved": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
-      "integrity": "sha512-6C/aND5PqOVzujwoS0rvUR963VxJ+MO0X+IZg9WpjrxBbuFag7fXay5yyamH0cKoTvmaTT2s8fca8pK0zQ0CYg==",
-      "hasInstallScript": true,
-      "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
-      "dependencies": {
-        "@types/lodash.snakecase": "^4.1.9",
-        "@types/protobufjs": "^6.0.0",
-        "@zod/core": "^0.11.6",
-        "ajv": "^8.17.1",
-        "ajv-formats": "^3.0.1",
-        "assemblyai": "^4.17.0",
-        "chalk": "^4.1.2",
-        "decompress": "^4.2.1",
-        "decompress-targz": "^4.1.1",
-        "decompress-unzip": "^4.0.1",
-        "groq-sdk": "^0.33.0",
-        "lodash.snakecase": "^4.1.1",
-        "node-record-lpcm16": "^1.0.1",
-        "protobufjs": "^7.5.4",
-        "uuid": "^11.1.0",
-        "zod-to-json-schema": "^3.25.0"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@inworld/runtime/node_modules/@types/node": {
-      "version": "18.19.130",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
-      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/@inworld/runtime/node_modules/groq-sdk": {
-      "version": "0.33.0",
-      "resolved": "https://registry.npmjs.org/groq-sdk/-/groq-sdk-0.33.0.tgz",
-      "integrity": "sha512-wb7NrBq7LZDDhDPSpuAd9LpZ0MNjmWKGLfybYfjY3r63mSpfiP8+GQZQcSDJcX+jIMzSm+SwzxModDyVZ2T66Q==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7"
-      }
-    },
-    "node_modules/@inworld/runtime/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
-      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
-      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
-    "node_modules/@opentelemetry/api": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
-      "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/@pinojs/redact": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz",
-      "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
-      "license": "MIT"
-    },
-    "node_modules/@protobufjs/aspromise": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
-      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/base64": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
-      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/codegen": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
-      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/eventemitter": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
-      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/fetch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
-      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@protobufjs/aspromise": "^1.1.1",
-        "@protobufjs/inquire": "^1.1.0"
-      }
-    },
-    "node_modules/@protobufjs/float": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
-      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/inquire": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
-      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/path": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
-      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/pool": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
-      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@protobufjs/utf8": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
-      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@tsconfig/node10": {
-      "version": "1.0.12",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.12.tgz",
-      "integrity": "sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node12": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
-      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node14": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
-      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node16": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
-      "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.6",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
-      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/cors": {
-      "version": "2.8.19",
-      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
-      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/express": {
-      "version": "5.0.6",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.6.tgz",
-      "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^5.0.0",
-        "@types/serve-static": "^2"
-      }
-    },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.1.0.tgz",
-      "integrity": "sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/express-validator": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@types/express-validator/-/express-validator-3.0.2.tgz",
-      "integrity": "sha512-dV+1u6absDDEIVe5jd5ID1XYvPPvOSvggMWh09VYM3TeBjAjBDtwJWyJg/5PnK7s8FRgbOtHgD6oX3N2MKWwDw==",
-      "deprecated": "This is a stub types definition. express-validator provides its own type definitions, so you do not need this installed.",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "express-validator": "*"
-      }
-    },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
-      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-FOvQ0YPD5NOfPgMzJihoT+Za5pdkDJWcbpuj1DjaKZIr/gxodQjY/uWEFlTNqW2ugXHUiL8lRQgw63dzKHZdeQ==",
-      "license": "MIT"
-    },
-    "node_modules/@types/lodash.snakecase": {
-      "version": "4.1.9",
-      "resolved": "https://registry.npmjs.org/@types/lodash.snakecase/-/lodash.snakecase-4.1.9.tgz",
-      "integrity": "sha512-emBZJUiNlo+QPXr1junMKXwzHJK9zbFvTVdyAoorFcm1YRsbzkZCYPTVMM9AW+dlnA6utG7vpfvOs8alxv/TMw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/lodash": "*"
-      }
-    },
-    "node_modules/@types/node": {
-      "version": "22.19.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.2.tgz",
-      "integrity": "sha512-LPM2G3Syo1GLzXLGJAKdqoU35XvrWzGJ21/7sgZTUpbkBaOasTj8tjwn6w+hCkqaa1TfJ/w67rJSwYItlJ2mYw==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.21.0"
-      }
-    },
-    "node_modules/@types/node-fetch": {
-      "version": "2.6.13",
-      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz",
-      "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "form-data": "^4.0.4"
-      }
-    },
-    "node_modules/@types/protobufjs": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/@types/protobufjs/-/protobufjs-6.0.0.tgz",
-      "integrity": "sha512-A27RDExpAf3rdDjIrHKiJK6x8kqqJ4CmoChwtipfhVAn1p7+wviQFFP7dppn8FslSbHtQeVPvi8wNKkDjSYjHw==",
-      "deprecated": "This is a stub types definition for protobufjs (https://github.com/dcodeIO/ProtoBuf.js). protobufjs provides its own type definitions, so you don't need @types/protobufjs installed!",
-      "license": "MIT",
-      "dependencies": {
-        "protobufjs": "*"
-      }
-    },
-    "node_modules/@types/qs": {
-      "version": "6.14.0",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz",
-      "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
-      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/send": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz",
-      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-static": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-2.2.0.tgz",
-      "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/http-errors": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@zod/core": {
-      "version": "0.11.6",
-      "resolved": "https://registry.npmjs.org/@zod/core/-/core-0.11.6.tgz",
-      "integrity": "sha512-03Bv82fFSfjDAvMfdHHdGSS6SOJs0iCcJlWJv1kJHRtoTT02hZpyip/2Lk6oo4l4FtjuwTrsEQTwg/LD8I7dJA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "license": "MIT",
-      "dependencies": {
-        "event-target-shim": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6.5"
-      }
-    },
-    "node_modules/accepts": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
-      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-types": "^3.0.0",
-        "negotiator": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-walk": {
-      "version": "8.3.4",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
-      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "acorn": "^8.11.0"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/agentkeepalive": {
-      "version": "4.6.0",
-      "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz",
-      "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==",
-      "license": "MIT",
-      "dependencies": {
-        "humanize-ms": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 8.0.0"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-uri": "^3.0.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/ajv-formats": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
-      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/arg": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
-      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/assemblyai": {
-      "version": "4.21.0",
-      "resolved": "https://registry.npmjs.org/assemblyai/-/assemblyai-4.21.0.tgz",
-      "integrity": "sha512-Nbbtk3wwHB1vhi7+98kYi/e9N9EFY0wAv5OuKXNmGw9eHkHG2r3ytgYOigcXyzC8cCvQdhA8Y0JCQm2BFDOOlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ws": "^8.18.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
-      "license": "MIT"
-    },
-    "node_modules/atomic-sleep": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz",
-      "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/binary-extensions": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
-      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/bintrees": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/bintrees/-/bintrees-1.0.2.tgz",
-      "integrity": "sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==",
-      "license": "MIT"
-    },
-    "node_modules/bl": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/bl/-/bl-1.2.3.tgz",
-      "integrity": "sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==",
-      "license": "MIT",
-      "dependencies": {
-        "readable-stream": "^2.3.5",
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "node_modules/body-parser": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.1.tgz",
-      "integrity": "sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==",
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "^3.1.2",
-        "content-type": "^1.0.5",
-        "debug": "^4.4.3",
-        "http-errors": "^2.0.0",
-        "iconv-lite": "^0.7.0",
-        "on-finished": "^2.4.1",
-        "qs": "^6.14.0",
-        "raw-body": "^3.0.1",
-        "type-is": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/buffer": {
-      "version": "5.7.1",
-      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
-      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.1.13"
-      }
-    },
-    "node_modules/buffer-alloc": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz",
-      "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==",
-      "license": "MIT",
-      "dependencies": {
-        "buffer-alloc-unsafe": "^1.1.0",
-        "buffer-fill": "^1.0.0"
-      }
-    },
-    "node_modules/buffer-alloc-unsafe": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz",
-      "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==",
-      "license": "MIT"
-    },
-    "node_modules/buffer-crc32": {
-      "version": "0.2.13",
-      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
-      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/buffer-fill": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz",
-      "integrity": "sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==",
-      "license": "MIT"
-    },
-    "node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/chokidar": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
-      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "license": "MIT"
-    },
-    "node_modules/colorette": {
-      "version": "2.0.20",
-      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
-      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
-      "license": "MIT"
-    },
-    "node_modules/combined-stream": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "license": "MIT",
-      "dependencies": {
-        "delayed-stream": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/commander": {
-      "version": "2.20.3",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
-      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/content-disposition": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz",
-      "integrity": "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
-      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
-      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie-signature": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
-      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.6.0"
-      }
-    },
-    "node_modules/core-util-is": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
-      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
-      "license": "MIT"
-    },
-    "node_modules/cors": {
-      "version": "2.8.5",
-      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
-      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
-      "license": "MIT",
-      "dependencies": {
-        "object-assign": "^4",
-        "vary": "^1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/create-require": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
-      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/dateformat": {
-      "version": "4.6.3",
-      "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-4.6.3.tgz",
-      "integrity": "sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/decompress": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/decompress/-/decompress-4.2.1.tgz",
-      "integrity": "sha512-e48kc2IjU+2Zw8cTb6VZcJQ3lgVbS4uuB1TfCHbiZIP/haNXm+SVyhu+87jts5/3ROpd82GSVCoNs/z8l4ZOaQ==",
-      "license": "MIT",
-      "dependencies": {
-        "decompress-tar": "^4.0.0",
-        "decompress-tarbz2": "^4.0.0",
-        "decompress-targz": "^4.0.0",
-        "decompress-unzip": "^4.0.1",
-        "graceful-fs": "^4.1.10",
-        "make-dir": "^1.0.0",
-        "pify": "^2.3.0",
-        "strip-dirs": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-tar": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/decompress-tar/-/decompress-tar-4.1.1.tgz",
-      "integrity": "sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==",
-      "license": "MIT",
-      "dependencies": {
-        "file-type": "^5.2.0",
-        "is-stream": "^1.1.0",
-        "tar-stream": "^1.5.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-tarbz2": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz",
-      "integrity": "sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==",
-      "license": "MIT",
-      "dependencies": {
-        "decompress-tar": "^4.1.0",
-        "file-type": "^6.1.0",
-        "is-stream": "^1.1.0",
-        "seek-bzip": "^1.0.5",
-        "unbzip2-stream": "^1.0.9"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-tarbz2/node_modules/file-type": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/file-type/-/file-type-6.2.0.tgz",
-      "integrity": "sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-targz": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/decompress-targz/-/decompress-targz-4.1.1.tgz",
-      "integrity": "sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==",
-      "license": "MIT",
-      "dependencies": {
-        "decompress-tar": "^4.1.1",
-        "file-type": "^5.2.0",
-        "is-stream": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-unzip": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/decompress-unzip/-/decompress-unzip-4.0.1.tgz",
-      "integrity": "sha512-1fqeluvxgnn86MOh66u8FjbtJpAFv5wgCT9Iw8rcBqQcCo5tO8eiJw7NNTrvt9n4CRBVq7CstiS922oPgyGLrw==",
-      "license": "MIT",
-      "dependencies": {
-        "file-type": "^3.8.0",
-        "get-stream": "^2.2.0",
-        "pify": "^2.3.0",
-        "yauzl": "^2.4.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/decompress-unzip/node_modules/file-type": {
-      "version": "3.9.0",
-      "resolved": "https://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz",
-      "integrity": "sha512-RLoqTXE8/vPmMuTI88DAzhMYC99I8BWv7zYP4A1puo5HIjEJ5EX48ighy4ZyKMG9EDXxBgW6e++cn7d1xuFghA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/delayed-stream": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
-      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/diff": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
-    "node_modules/dotenv": {
-      "version": "16.6.1",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
-      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://dotenvx.com"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "license": "MIT"
-    },
-    "node_modules/encodeurl": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
-      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/end-of-stream": {
-      "version": "1.4.5",
-      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
-      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
-      "license": "MIT",
-      "dependencies": {
-        "once": "^1.4.0"
-      }
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "license": "MIT"
-    },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/express": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
-      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "^2.0.0",
-        "body-parser": "^2.2.1",
-        "content-disposition": "^1.0.0",
-        "content-type": "^1.0.5",
-        "cookie": "^0.7.1",
-        "cookie-signature": "^1.2.1",
-        "debug": "^4.4.0",
-        "depd": "^2.0.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "finalhandler": "^2.1.0",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.0",
-        "merge-descriptors": "^2.0.0",
-        "mime-types": "^3.0.0",
-        "on-finished": "^2.4.1",
-        "once": "^1.4.0",
-        "parseurl": "^1.3.3",
-        "proxy-addr": "^2.0.7",
-        "qs": "^6.14.0",
-        "range-parser": "^1.2.1",
-        "router": "^2.2.0",
-        "send": "^1.1.0",
-        "serve-static": "^2.2.0",
-        "statuses": "^2.0.1",
-        "type-is": "^2.0.1",
-        "vary": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/express-validator": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/express-validator/-/express-validator-7.3.1.tgz",
-      "integrity": "sha512-IGenaSf+DnWc69lKuqlRE9/i/2t5/16VpH5bXoqdxWz1aCpRvEdrBuu1y95i/iL5QP8ZYVATiwLFhwk3EDl5vg==",
-      "license": "MIT",
-      "dependencies": {
-        "lodash": "^4.17.21",
-        "validator": "~13.15.23"
-      },
-      "engines": {
-        "node": ">= 8.0.0"
-      }
-    },
-    "node_modules/fast-copy": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/fast-copy/-/fast-copy-4.0.1.tgz",
-      "integrity": "sha512-+uUOQlhsaswsizHFmEFAQhB3lSiQ+lisxl50N6ZP0wywlZeWsIESxSi9ftPEps8UGfiBzyYP7x27zA674WUvXw==",
-      "license": "MIT"
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "license": "MIT"
-    },
-    "node_modules/fast-safe-stringify": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
-      "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
-      "license": "MIT"
-    },
-    "node_modules/fast-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
-      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/fd-slicer": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
-      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
-      "license": "MIT",
-      "dependencies": {
-        "pend": "~1.2.0"
-      }
-    },
-    "node_modules/file-type": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/file-type/-/file-type-5.2.0.tgz",
-      "integrity": "sha512-Iq1nJ6D2+yIO4c8HHg4fyVb8mAJieo1Oloy1mLLaB2PvezNedhBVm+QU7g0qM42aiMbRXTxKKwGD17rjKNJYVQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/finalhandler": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
-      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "on-finished": "^2.4.1",
-        "parseurl": "^1.3.3",
-        "statuses": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 18.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/form-data": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
-      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
-      "license": "MIT",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "es-set-tostringtag": "^2.1.0",
-        "hasown": "^2.0.2",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/form-data-encoder": {
-      "version": "1.7.2",
-      "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz",
-      "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==",
-      "license": "MIT"
-    },
-    "node_modules/form-data/node_modules/mime-db": {
-      "version": "1.52.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
-      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/form-data/node_modules/mime-types": {
-      "version": "2.1.35",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
-      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "1.52.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/formdata-node": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz",
-      "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==",
-      "license": "MIT",
-      "dependencies": {
-        "node-domexception": "1.0.0",
-        "web-streams-polyfill": "4.0.0-beta.3"
-      },
-      "engines": {
-        "node": ">= 12.20"
-      }
-    },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
-      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fresh": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
-      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/fs-constants": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
-      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
-      "license": "MIT"
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-stream": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-2.3.1.tgz",
-      "integrity": "sha512-AUGhbbemXxrZJRD5cDvKtQxLuYaIbNtDTK8YqupCI393Q2KSTreEsLUN3ZxAWFGiKTzL6nKuzfcIvieflUX9qA==",
-      "license": "MIT",
-      "dependencies": {
-        "object-assign": "^4.0.1",
-        "pinkie-promise": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "license": "ISC"
-    },
-    "node_modules/groq-sdk": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/groq-sdk/-/groq-sdk-0.7.0.tgz",
-      "integrity": "sha512-OgPqrRtti5MjEVclR8sgBHrhSkTLdFCmi47yrEF29uJZaiCkX3s7bXpnMhq8Lwoe1f4AwgC0qGOeHXpeSgu5lg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7"
-      }
-    },
-    "node_modules/groq-sdk/node_modules/@types/node": {
-      "version": "18.19.130",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
-      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/groq-sdk/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "license": "MIT"
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/help-me": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/help-me/-/help-me-5.0.0.tgz",
-      "integrity": "sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==",
-      "license": "MIT"
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
-      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
-      "license": "MIT",
-      "dependencies": {
-        "depd": "~2.0.0",
-        "inherits": "~2.0.4",
-        "setprototypeof": "~1.2.0",
-        "statuses": "~2.0.2",
-        "toidentifier": "~1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/humanize-ms": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
-      "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.0.0"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.7.1",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.1.tgz",
-      "integrity": "sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==",
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/ieee754": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/ignore-by-default": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
-      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "license": "ISC"
-    },
-    "node_modules/ipaddr.js": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
-      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/is-binary-path": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
-      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "binary-extensions": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-natural-number": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-natural-number/-/is-natural-number-4.0.1.tgz",
-      "integrity": "sha512-Y4LTamMe0DDQIIAlaer9eKebAlDSV6huy+TWhJVPlzZh2o4tRP5SQWFlLn5N0To4mDD22/qdOq+veo1cSISLgQ==",
-      "license": "MIT"
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-promise": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
-      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
-      "license": "MIT"
-    },
-    "node_modules/is-stream": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
-      "integrity": "sha512-uQPm8kcs47jx38atAcWTVxyltQYoPT68y9aWYdV6yWXSyW8mzSat0TL6CiWdZeCdF3KrAvpVtnHbTv4RN+rqdQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
-      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
-      "license": "MIT",
-      "dependencies": {
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
-      "license": "MIT"
-    },
-    "node_modules/joycon": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
-      "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "license": "MIT"
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
-      "license": "MIT"
-    },
-    "node_modules/lodash.snakecase": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz",
-      "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==",
-      "license": "MIT"
-    },
-    "node_modules/long": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
-      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/make-dir": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz",
-      "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==",
-      "license": "MIT",
-      "dependencies": {
-        "pify": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/make-dir/node_modules/pify": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
-      "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/make-error": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
-      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/media-typer": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
-      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/merge-descriptors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
-      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/mime-db": {
-      "version": "1.54.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
-      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
-      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "^1.54.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/negotiator": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
-      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/node-domexception": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
-      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
-      "deprecated": "Use your platform's native DOMException instead",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "github",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.5.0"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
-      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
-      "license": "MIT",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/node-record-lpcm16": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/node-record-lpcm16/-/node-record-lpcm16-1.0.1.tgz",
-      "integrity": "sha512-H75GMOP8ErnF67m21+qSgj4USnzv5RLfm7OkEItdIi+soNKoJZpMQPX6umM8Cn9nVPSgd/dBUtc1msst5MmABA==",
-      "license": "ISC",
-      "dependencies": {
-        "debug": "^2.6.8"
-      }
-    },
-    "node_modules/node-record-lpcm16/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/node-record-lpcm16/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/nodemon": {
-      "version": "3.1.11",
-      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.11.tgz",
-      "integrity": "sha512-is96t8F/1//UHAjNPHpbsNY46ELPpftGUoSVNXwUfMk/qdjSylYrWSu1XavVTBOn526kFiOR733ATgNBCQyH0g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chokidar": "^3.5.2",
-        "debug": "^4",
-        "ignore-by-default": "^1.0.1",
-        "minimatch": "^3.1.2",
-        "pstree.remy": "^1.1.8",
-        "semver": "^7.5.3",
-        "simple-update-notifier": "^2.0.0",
-        "supports-color": "^5.5.0",
-        "touch": "^3.1.0",
-        "undefsafe": "^2.0.5"
-      },
-      "bin": {
-        "nodemon": "bin/nodemon.js"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/nodemon"
-      }
-    },
-    "node_modules/nodemon/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/nodemon/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/normalize-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
-      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/on-exit-leak-free": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
-      "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/on-finished": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
-      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
-      "license": "MIT",
-      "dependencies": {
-        "ee-first": "1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/parseurl": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
-      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/path-to-regexp": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz",
-      "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==",
-      "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/pend": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
-      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
-      "license": "MIT"
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/pify": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
-      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/pinkie": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz",
-      "integrity": "sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/pinkie-promise": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz",
-      "integrity": "sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==",
-      "license": "MIT",
-      "dependencies": {
-        "pinkie": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/pino": {
-      "version": "9.14.0",
-      "resolved": "https://registry.npmjs.org/pino/-/pino-9.14.0.tgz",
-      "integrity": "sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==",
-      "license": "MIT",
-      "dependencies": {
-        "@pinojs/redact": "^0.4.0",
-        "atomic-sleep": "^1.0.0",
-        "on-exit-leak-free": "^2.1.0",
-        "pino-abstract-transport": "^2.0.0",
-        "pino-std-serializers": "^7.0.0",
-        "process-warning": "^5.0.0",
-        "quick-format-unescaped": "^4.0.3",
-        "real-require": "^0.2.0",
-        "safe-stable-stringify": "^2.3.1",
-        "sonic-boom": "^4.0.1",
-        "thread-stream": "^3.0.0"
-      },
-      "bin": {
-        "pino": "bin.js"
-      }
-    },
-    "node_modules/pino-abstract-transport": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz",
-      "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==",
-      "license": "MIT",
-      "dependencies": {
-        "split2": "^4.0.0"
-      }
-    },
-    "node_modules/pino-pretty": {
-      "version": "13.1.3",
-      "resolved": "https://registry.npmjs.org/pino-pretty/-/pino-pretty-13.1.3.tgz",
-      "integrity": "sha512-ttXRkkOz6WWC95KeY9+xxWL6AtImwbyMHrL1mSwqwW9u+vLp/WIElvHvCSDg0xO/Dzrggz1zv3rN5ovTRVowKg==",
-      "license": "MIT",
-      "dependencies": {
-        "colorette": "^2.0.7",
-        "dateformat": "^4.6.3",
-        "fast-copy": "^4.0.0",
-        "fast-safe-stringify": "^2.1.1",
-        "help-me": "^5.0.0",
-        "joycon": "^3.1.1",
-        "minimist": "^1.2.6",
-        "on-exit-leak-free": "^2.1.0",
-        "pino-abstract-transport": "^3.0.0",
-        "pump": "^3.0.0",
-        "secure-json-parse": "^4.0.0",
-        "sonic-boom": "^4.0.1",
-        "strip-json-comments": "^5.0.2"
-      },
-      "bin": {
-        "pino-pretty": "bin.js"
-      }
-    },
-    "node_modules/pino-pretty/node_modules/pino-abstract-transport": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-3.0.0.tgz",
-      "integrity": "sha512-wlfUczU+n7Hy/Ha5j9a/gZNy7We5+cXp8YL+X+PG8S0KXxw7n/JXA3c46Y0zQznIJ83URJiwy7Lh56WLokNuxg==",
-      "license": "MIT",
-      "dependencies": {
-        "split2": "^4.0.0"
-      }
-    },
-    "node_modules/pino-std-serializers": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz",
-      "integrity": "sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==",
-      "license": "MIT"
-    },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
-      "license": "MIT"
-    },
-    "node_modules/process-warning": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz",
-      "integrity": "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/prom-client": {
-      "version": "15.1.3",
-      "resolved": "https://registry.npmjs.org/prom-client/-/prom-client-15.1.3.tgz",
-      "integrity": "sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@opentelemetry/api": "^1.4.0",
-        "tdigest": "^0.1.1"
-      },
-      "engines": {
-        "node": "^16 || ^18 || >=20"
-      }
-    },
-    "node_modules/protobufjs": {
-      "version": "7.5.4",
-      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
-      "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==",
-      "hasInstallScript": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@protobufjs/aspromise": "^1.1.2",
-        "@protobufjs/base64": "^1.1.2",
-        "@protobufjs/codegen": "^2.0.4",
-        "@protobufjs/eventemitter": "^1.1.0",
-        "@protobufjs/fetch": "^1.1.0",
-        "@protobufjs/float": "^1.0.2",
-        "@protobufjs/inquire": "^1.1.0",
-        "@protobufjs/path": "^1.1.2",
-        "@protobufjs/pool": "^1.1.0",
-        "@protobufjs/utf8": "^1.1.0",
-        "@types/node": ">=13.7.0",
-        "long": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      }
-    },
-    "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
-      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
-      "license": "MIT",
-      "dependencies": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/pstree.remy": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
-      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/pump": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
-      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
-      "license": "MIT",
-      "dependencies": {
-        "end-of-stream": "^1.1.0",
-        "once": "^1.3.1"
-      }
-    },
-    "node_modules/qs": {
-      "version": "6.14.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
-      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/quick-format-unescaped": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz",
-      "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==",
-      "license": "MIT"
-    },
-    "node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/raw-body": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz",
-      "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==",
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "~3.1.2",
-        "http-errors": "~2.0.1",
-        "iconv-lite": "~0.7.0",
-        "unpipe": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/readable-stream": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
-      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
-      "license": "MIT",
-      "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "node_modules/readable-stream/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "license": "MIT"
-    },
-    "node_modules/readdirp": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
-      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "picomatch": "^2.2.1"
-      },
-      "engines": {
-        "node": ">=8.10.0"
-      }
-    },
-    "node_modules/real-require": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz",
-      "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12.13.0"
-      }
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/router": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
-      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "depd": "^2.0.0",
-        "is-promise": "^4.0.0",
-        "parseurl": "^1.3.3",
-        "path-to-regexp": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/safe-stable-stringify": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
-      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "license": "MIT"
-    },
-    "node_modules/secure-json-parse": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-4.1.0.tgz",
-      "integrity": "sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/seek-bzip": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.6.tgz",
-      "integrity": "sha512-e1QtP3YL5tWww8uKaOCQ18UxIT2laNBXHjV/S2WYCiK4udiv8lkG89KRIoCjUagnAmCBurjF4zEVX2ByBbnCjQ==",
-      "license": "MIT",
-      "dependencies": {
-        "commander": "^2.8.1"
-      },
-      "bin": {
-        "seek-bunzip": "bin/seek-bunzip",
-        "seek-table": "bin/seek-bzip-table"
-      }
-    },
-    "node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/send": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
-      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.5",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.0",
-        "mime-types": "^3.0.1",
-        "ms": "^2.1.3",
-        "on-finished": "^2.4.1",
-        "range-parser": "^1.2.1",
-        "statuses": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/serve-static": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
-      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
-      "license": "MIT",
-      "dependencies": {
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "parseurl": "^1.3.3",
-        "send": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/setprototypeof": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
-      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-      "license": "ISC"
-    },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/simple-update-notifier": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
-      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "semver": "^7.5.3"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/sonic-boom": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.0.tgz",
-      "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==",
-      "license": "MIT",
-      "dependencies": {
-        "atomic-sleep": "^1.0.0"
-      }
-    },
-    "node_modules/split2": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-      "license": "ISC",
-      "engines": {
-        "node": ">= 10.x"
-      }
-    },
-    "node_modules/statuses": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
-      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "license": "MIT"
-    },
-    "node_modules/strip-bom": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/strip-dirs": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz",
-      "integrity": "sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==",
-      "license": "MIT",
-      "dependencies": {
-        "is-natural-number": "^4.0.1"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.3.tgz",
-      "integrity": "sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/tar-stream": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.2.tgz",
-      "integrity": "sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==",
-      "license": "MIT",
-      "dependencies": {
-        "bl": "^1.0.0",
-        "buffer-alloc": "^1.2.0",
-        "end-of-stream": "^1.0.0",
-        "fs-constants": "^1.0.0",
-        "readable-stream": "^2.3.0",
-        "to-buffer": "^1.1.1",
-        "xtend": "^4.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/tdigest": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/tdigest/-/tdigest-0.1.2.tgz",
-      "integrity": "sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==",
-      "license": "MIT",
-      "dependencies": {
-        "bintrees": "1.0.2"
-      }
-    },
-    "node_modules/thread-stream": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
-      "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==",
-      "license": "MIT",
-      "dependencies": {
-        "real-require": "^0.2.0"
-      }
-    },
-    "node_modules/through": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
-      "license": "MIT"
-    },
-    "node_modules/to-buffer": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.2.tgz",
-      "integrity": "sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==",
-      "license": "MIT",
-      "dependencies": {
-        "isarray": "^2.0.5",
-        "safe-buffer": "^5.2.1",
-        "typed-array-buffer": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/to-buffer/node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "license": "MIT"
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/toidentifier": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
-      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/touch": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
-      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "nodetouch": "bin/nodetouch.js"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
-      "license": "MIT"
-    },
-    "node_modules/ts-node": {
-      "version": "10.9.2",
-      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
-      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      },
-      "bin": {
-        "ts-node": "dist/bin.js",
-        "ts-node-cwd": "dist/bin-cwd.js",
-        "ts-node-esm": "dist/bin-esm.js",
-        "ts-node-script": "dist/bin-script.js",
-        "ts-node-transpile-only": "dist/bin-transpile.js",
-        "ts-script": "dist/bin-script-deprecated.js"
-      },
-      "peerDependencies": {
-        "@swc/core": ">=1.2.50",
-        "@swc/wasm": ">=1.2.50",
-        "@types/node": "*",
-        "typescript": ">=2.7"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "@swc/wasm": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tsconfig-paths": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
-      "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "json5": "^2.2.2",
-        "minimist": "^1.2.6",
-        "strip-bom": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/type-is": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
-      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
-      "license": "MIT",
-      "dependencies": {
-        "content-type": "^1.0.5",
-        "media-typer": "^1.1.0",
-        "mime-types": "^3.0.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/typed-array-buffer": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
-      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/unbzip2-stream": {
-      "version": "1.4.3",
-      "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
-      "integrity": "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==",
-      "license": "MIT",
-      "dependencies": {
-        "buffer": "^5.2.1",
-        "through": "^2.3.8"
-      }
-    },
-    "node_modules/undefsafe": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
-      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/undici-types": {
-      "version": "6.21.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "license": "MIT"
-    },
-    "node_modules/unpipe": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
-      "license": "MIT"
-    },
-    "node_modules/uuid": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
-      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/esm/bin/uuid"
-      }
-    },
-    "node_modules/v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
-      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/validator": {
-      "version": "13.15.23",
-      "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.23.tgz",
-      "integrity": "sha512-4yoz1kEWqUjzi5zsPbAS/903QXSYp0UOtHsPpp7p9rHAw/W+dkInskAE386Fat3oKRROwO98d9ZB0G4cObgUyw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/vary": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/wav-encoder": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/wav-encoder/-/wav-encoder-1.3.0.tgz",
-      "integrity": "sha512-FXJdEu2qDOI+wbVYZpu21CS1vPEg5NaxNskBr4SaULpOJMrLE6xkH8dECa7PiS+ZoeyvP7GllWUAxPN3AvFSEw==",
-      "license": "MIT"
-    },
-    "node_modules/web-streams-polyfill": {
-      "version": "4.0.0-beta.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
-      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "license": "MIT",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.19",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
-      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "for-each": "^0.3.5",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "license": "ISC"
-    },
-    "node_modules/ws": {
-      "version": "8.18.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
-      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/xtend": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
-      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4"
-      }
-    },
-    "node_modules/yauzl": {
-      "version": "2.10.0",
-      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
-      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
-      "license": "MIT",
-      "dependencies": {
-        "buffer-crc32": "~0.2.3",
-        "fd-slicer": "~1.1.0"
-      }
-    },
-    "node_modules/yn": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
-      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/zod": {
-      "version": "4.1.13",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-4.1.13.tgz",
-      "integrity": "sha512-AvvthqfqrAhNH9dnfmrfKzX5upOdjUVJYFqNSlkmGf64gRaTzlPwz99IHYnVs28qYAybvAlBV+H7pn0saFY4Ig==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/zod-to-json-schema": {
-      "version": "3.25.0",
-      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.0.tgz",
-      "integrity": "sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==",
-      "license": "ISC",
-      "peerDependencies": {
-        "zod": "^3.25 || ^4"
-      }
-    }
-  }
-}
diff --git a/realtime-service/src/package.json b/realtime-service/src/package.json
deleted file mode 100644
index d12a8f1..0000000
--- a/realtime-service/src/package.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "name": "server",
-  "main": "index.js",
-  "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
-  "scripts": {
-    "start": "nodemon -r tsconfig-paths/register index.ts",
-    "start:debug": "node-ts index.ts",
-    "build": "tsc"
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.17",
-    "@types/express": "^5.0.1",
-    "@types/express-validator": "^3.0.0",
-    "@types/node": "^22.14.0",
-    "@types/ws": "^8.18.1",
-    "nodemon": "^3.1.9",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
-    "cors": "^2.8.5",
-    "dotenv": "^16.4.7",
-    "express": "^5.1.0",
-    "express-validator": "^7.2.1",
-    "groq-sdk": "^0.7.0",
-    "pino": "^9.14.0",
-    "pino-pretty": "^13.1.2",
-    "prom-client": "^15.1.3",
-    "uuid": "^11.1.0",
-    "wav-encoder": "^1.3.0",
-    "ws": "^8.18.1",
-    "zod": "^4.1.13"
-  }
-}
diff --git a/realtime-service/src/tsconfig.json b/realtime-service/src/tsconfig.json
deleted file mode 100644
index fc82f5d..0000000
--- a/realtime-service/src/tsconfig.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "declaration": true,
-    "module": "Node16",
-    "moduleResolution": "node16",
-    "noImplicitAny": true,
-    "resolveJsonModule": true,
-    "target": "es6",
-    "types": ["node"],
-    "outDir": "./dist",
-    "rootDir": "./",
-    "baseUrl": ".",
-    "paths": {
-      "@inworld/runtime/common": ["./node_modules/@inworld/runtime/build/common/export"],
-      "@inworld/runtime/graph": ["./node_modules/@inworld/runtime/build/graph/export"],
-      "@inworld/runtime/graph/nodes": ["./node_modules/@inworld/runtime/build/graph/dsl/nodes/builtin/export"],
-      "@inworld/runtime/graph/components": ["./node_modules/@inworld/runtime/build/graph/dsl/components/export"],
-      "@inworld/runtime/core": ["./node_modules/@inworld/runtime/build/core/export"],
-      "@inworld/runtime/primitives/*": ["./node_modules/@inworld/runtime/build/primitives/*/index"],
-      "@inworld/runtime/telemetry": ["./node_modules/@inworld/runtime/build/telemetry/export"]
-    }
-  }
-}
diff --git a/realtime-service/src/types/index.ts b/realtime-service/src/types/index.ts
deleted file mode 100644
index 2a80e1f..0000000
--- a/realtime-service/src/types/index.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import { AudioChunkInterface } from '@inworld/runtime/common';
-import { GraphOutputStream } from '@inworld/runtime/graph';
-
-import { MultimodalStreamManager } from '../components/audio/multimodal_stream_manager';
-
-export enum EVENT_TYPE {
-  TEXT = 'TEXT',
-  AUDIO = 'AUDIO',
-  AUDIO_SESSION_END = 'audioSessionEnd',
-  NEW_INTERACTION = 'newInteraction',
-  CANCEL_RESPONSE = 'CANCEL_RESPONSE',
-}
-
-export enum AUDIO_SESSION_STATE {
-  PROCESSING = 'PROCESSING',
-  ACTIVE = 'ACTIVE',
-  INACTIVE = 'INACTIVE',
-}
-
-export interface ChatMessage {
-  id: string;
-  role: string;
-  content: string;
-  tool_call_id?: string; // For tool/function call outputs
-}
-
-export interface Agent {
-  id: string;
-  name: string;
-  description: string;
-  motivation: string;
-  knowledge?: string[];
-}
-
-export interface TextInput {
-  sessionId: string;
-  text: string;
-  interactionId: string;
-  voiceId?: string;
-}
-
-export interface AudioInput {
-  sessionId: string;
-  audio: AudioChunkInterface;
-  state: State;
-  interactionId: string;
-}
-
-export interface AudioStreamInput {
-  sessionId: string;
-  state: State;
-  voiceId?: string;
-}
-
-export interface State {
-  interactionId: string;
-  agent: Agent;
-  userName: string;
-  messages: ChatMessage[];
-  voiceId?: string;
-  tools?: any[];
-  toolChoice?: string | object;
-  eagerness?: 'low' | 'medium' | 'high';
-  output_modalities?: ('text' | 'audio')[];
-}
-
-export interface Connection {
-  apiKey: string;
-  workspaceId: string;
-  state: State;
-  ws: any;
-  unloaded?: true;
-  multimodalStreamManager?: MultimodalStreamManager;
-  currentAudioGraphExecution?: Promise<void>;
-  // Track execution streams so they can be aborted
-  currentAudioExecutionStream?: GraphOutputStream;
-  onSpeechDetected?: (interactionId: string) => void; // Callback when speech is detected (triggers input_audio_buffer.speech_started event)
-  onPartialTranscript?: (text: string, interactionId: string) => void; // Callback for partial transcripts
-}
-
-export type ConnectionsMap = {
-  [sessionId: string]: Connection;
-};
-
-export interface PromptInput {
-  agent: Agent;
-  messages: ChatMessage[];
-  userName: string;
-  userQuery: string;
-}
-
-export interface CreateGraphPropsInterface {
-  llmModelName: string;
-  llmProvider: string;
-  voiceId: string;
-  graphVisualizationEnabled: boolean;
-  connections: ConnectionsMap;
-  ttsModelId: string;
-  useAssemblyAI?: boolean; // Use Assembly.AI streaming STT (should always be true for audio input)
-  assemblyAIApiKey?: string; // Assembly.AI API key (required for audio input)
-  useMocks?: boolean; // Use mock components (FakeTTSComponent, FakeRemoteLLMComponent) instead of real ones
-}
-
-export interface InteractionInfo {
-  sessionId: string;
-  interactionId: string;
-  text: string;
-}
diff --git a/realtime-service/src/types/realtime.ts b/realtime-service/src/types/realtime.ts
deleted file mode 100644
index a71c088..0000000
--- a/realtime-service/src/types/realtime.ts
+++ /dev/null
@@ -1,526 +0,0 @@
-/**
- * OpenAI Realtime API Type Definitions
- * Based on the OpenAI Realtime API specification
- */
-
-import { GraphTypes } from '@inworld/runtime/graph';
-
-// ============================================================================
-// Client Events (sent from client to server)
-// ============================================================================
-
-export interface ClientEventBase {
-  event_id?: string;
-}
-
-export interface SessionUpdateEvent extends ClientEventBase {
-  type: 'session.update';
-  session: Partial<SessionConfig>;
-}
-
-export interface InputAudioBufferAppendEvent extends ClientEventBase {
-  type: 'input_audio_buffer.append';
-  audio: string; // base64-encoded audio
-}
-
-export interface InputAudioBufferCommitEvent extends ClientEventBase {
-  type: 'input_audio_buffer.commit';
-}
-
-export interface InputAudioBufferClearEvent extends ClientEventBase {
-  type: 'input_audio_buffer.clear';
-}
-
-export interface ConversationItemCreateEvent extends ClientEventBase {
-  type: 'conversation.item.create';
-  previous_item_id?: string;
-  item: ConversationItem;
-}
-
-export interface ConversationItemTruncateEvent extends ClientEventBase {
-  type: 'conversation.item.truncate';
-  item_id: string;
-  content_index: number;
-  audio_end_ms: number;
-}
-
-export interface ConversationItemDeleteEvent extends ClientEventBase {
-  type: 'conversation.item.delete';
-  item_id: string;
-}
-
-export interface ConversationItemRetrieveEvent extends ClientEventBase {
-  type: 'conversation.item.retrieve';
-  item_id: string;
-}
-
-export interface ResponseCreateEvent extends ClientEventBase {
-  type: 'response.create';
-  response?: ResponseConfig;
-}
-
-export interface ResponseCancelEvent extends ClientEventBase {
-  type: 'response.cancel';
-  response_id?: string;
-}
-
-export type ClientEvent =
-  | SessionUpdateEvent
-  | InputAudioBufferAppendEvent
-  | InputAudioBufferCommitEvent
-  | InputAudioBufferClearEvent
-  | ConversationItemCreateEvent
-  | ConversationItemTruncateEvent
-  | ConversationItemDeleteEvent
-  | ConversationItemRetrieveEvent
-  | ResponseCreateEvent
-  | ResponseCancelEvent;
-
-// ============================================================================
-// Server Events (sent from server to client)
-// ============================================================================
-
-export interface ServerEventBase {
-  event_id: string;
-}
-
-export interface SessionCreatedEvent extends ServerEventBase {
-  type: 'session.created';
-  session: Session;
-}
-
-export interface SessionUpdatedEvent extends ServerEventBase {
-  type: 'session.updated';
-  session: Session;
-}
-
-export interface ConversationItemAddedEvent extends ServerEventBase {
-  type: 'conversation.item.added';
-  previous_item_id: string | null;
-  item: ConversationItem;
-}
-
-export interface ConversationItemDoneEvent extends ServerEventBase {
-  type: 'conversation.item.done';
-  previous_item_id: string | null;
-  item: ConversationItem;
-}
-
-export interface ConversationItemRetrievedEvent extends ServerEventBase {
-  type: 'conversation.item.retrieved';
-  item: ConversationItem;
-}
-
-export interface ConversationItemTruncatedEvent extends ServerEventBase {
-  type: 'conversation.item.truncated';
-  item_id: string;
-  content_index: number;
-  audio_end_ms: number;
-}
-
-export interface ConversationItemDeletedEvent extends ServerEventBase {
-  type: 'conversation.item.deleted';
-  item_id: string;
-}
-
-export interface InputAudioBufferCommittedEvent extends ServerEventBase {
-  type: 'input_audio_buffer.committed';
-  previous_item_id: string | null;
-  item_id: string;
-}
-
-export interface InputAudioBufferClearedEvent extends ServerEventBase {
-  type: 'input_audio_buffer.cleared';
-}
-
-export interface InputAudioBufferSpeechStartedEvent extends ServerEventBase {
-  type: 'input_audio_buffer.speech_started';
-  audio_start_ms: number;
-  item_id: string;
-}
-
-export interface InputAudioBufferSpeechStoppedEvent extends ServerEventBase {
-  type: 'input_audio_buffer.speech_stopped';
-  audio_end_ms: number;
-  item_id: string;
-}
-
-export interface ConversationItemInputAudioTranscriptionDeltaEvent
-  extends ServerEventBase {
-  type: 'conversation.item.input_audio_transcription.delta';
-  item_id: string;
-  content_index: number;
-  delta: string;
-}
-
-export interface ConversationItemInputAudioTranscriptionCompletedEvent
-  extends ServerEventBase {
-  type: 'conversation.item.input_audio_transcription.completed';
-  item_id: string;
-  content_index: number;
-  transcript: string;
-}
-
-export interface ResponseCreatedEvent extends ServerEventBase {
-  type: 'response.created';
-  response: Response;
-}
-
-
-export interface ResponseDoneEvent extends ServerEventBase {
-  type: 'response.done';
-  response: Response;
-}
-
-export interface ResponseOutputItemAddedEvent extends ServerEventBase {
-  type: 'response.output_item.added';
-  response_id: string;
-  output_index: number;
-  item: ConversationItem;
-}
-
-export interface ResponseOutputItemDoneEvent extends ServerEventBase {
-  type: 'response.output_item.done';
-  response_id: string;
-  output_index: number;
-  item: ConversationItem;
-}
-
-export interface ResponseContentPartAddedEvent extends ServerEventBase {
-  type: 'response.content_part.added';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  part: ContentPart;
-}
-
-export interface ResponseContentPartDoneEvent extends ServerEventBase {
-  type: 'response.content_part.done';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  part: ContentPart;
-}
-
-export interface ResponseAudioDeltaEvent extends ServerEventBase {
-  type: 'response.output_audio.delta';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  delta: string; // base64-encoded audio
-}
-
-export interface ResponseAudioDoneEvent extends ServerEventBase {
-  type: 'response.output_audio.done';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-}
-
-export interface ResponseAudioTranscriptDeltaEvent extends ServerEventBase {
-  type: 'response.output_audio_transcript.delta';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  delta: string;
-}
-
-export interface ResponseAudioTranscriptDoneEvent extends ServerEventBase {
-  type: 'response.output_audio_transcript.done';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  transcript: string;
-}
-
-export interface ResponseFunctionCallArgumentsDeltaEvent extends ServerEventBase {
-  type: 'response.function_call_arguments.delta';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  call_id: string;
-  delta: string;
-}
-
-export interface ResponseFunctionCallArgumentsDoneEvent extends ServerEventBase {
-  type: 'response.function_call_arguments.done';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  call_id: string;
-  arguments: string;
-}
-
-export interface ResponseTextDeltaEvent extends ServerEventBase {
-  type: 'response.output_text.delta';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  delta: string;
-}
-
-export interface ResponseTextDoneEvent extends ServerEventBase {
-  type: 'response.output_text.done';
-  response_id: string;
-  item_id: string;
-  output_index: number;
-  content_index: number;
-  text: string;
-}
-
-export interface ErrorEvent extends ServerEventBase {
-  type: 'error';
-  error: {
-    type: string;
-    code: string | null;
-    message: string;
-    param: string | null;
-    event_id: string | null;
-  };
-}
-
-export interface RateLimitsUpdatedEvent extends ServerEventBase {
-  type: 'rate_limits.updated';
-  rate_limits: Array<{
-    name: 'requests' | 'tokens';
-    limit: number;
-    remaining: number;
-    reset_seconds: number;
-  }>;
-}
-
-export type ServerEvent =
-  | SessionCreatedEvent
-  | SessionUpdatedEvent
-  | ConversationItemAddedEvent
-  | ConversationItemDoneEvent
-  | ConversationItemRetrievedEvent
-  | ConversationItemTruncatedEvent
-  | ConversationItemDeletedEvent
-  | InputAudioBufferCommittedEvent
-  | InputAudioBufferClearedEvent
-  | InputAudioBufferSpeechStartedEvent
-  | InputAudioBufferSpeechStoppedEvent
-  | ConversationItemInputAudioTranscriptionDeltaEvent
-  | ConversationItemInputAudioTranscriptionCompletedEvent
-  | ResponseCreatedEvent
-  | ResponseDoneEvent
-  | ResponseOutputItemAddedEvent
-  | ResponseOutputItemDoneEvent
-  | ResponseContentPartAddedEvent
-  | ResponseContentPartDoneEvent
-  | ResponseAudioDeltaEvent
-  | ResponseAudioDoneEvent
-  | ResponseAudioTranscriptDeltaEvent
-  | ResponseAudioTranscriptDoneEvent
-  | ResponseFunctionCallArgumentsDeltaEvent
-  | ResponseFunctionCallArgumentsDoneEvent
-  | ResponseTextDeltaEvent
-  | ResponseTextDoneEvent
-  | ErrorEvent
-  | RateLimitsUpdatedEvent;
-
-// ============================================================================
-// Data Types
-// ============================================================================
-
-export interface AudioInputConfig {
-  format: {
-    type: 'audio/pcm';
-    rate: 24000;
-  };
-  transcription?: {
-    model: string;
-    language?: string;
-  } | null;
-  noise_reduction?: {
-    type: 'near_field' | 'far_field';
-  } | null;
-  turn_detection?: TurnDetection | null;
-}
-
-export interface AudioOutputConfig {
-  format: {
-    type: 'audio/pcm';
-    rate: 24000;
-  };
-  voice: string;
-  speed?: number;
-}
-
-export interface SessionConfig {
-  output_modalities?: ('text' | 'audio')[];
-  instructions?: string;
-  audio?: {
-    input?: Partial<AudioInputConfig>;
-    output?: Partial<AudioOutputConfig>;
-  };
-  tools?: Tool[];
-  tool_choice?: 'auto' | 'none' | 'required';
-  temperature?: number;
-  max_output_tokens?: number | 'inf';
-  truncation?: 'auto' | 'disabled';
-  prompt?: string | null;
-  tracing?: string | null;
-  include?: string[] | null;
-}
-
-export interface Session {
-  type: 'realtime';
-  id: string;
-  object: 'realtime.session';
-  model: string;
-  output_modalities: ('text' | 'audio')[];
-  instructions: string;
-  audio: {
-    input: AudioInputConfig;
-    output: AudioOutputConfig;
-  };
-  tools: Tool[];
-  tool_choice: 'auto' | 'none' | 'required';
-  temperature: number;
-  max_output_tokens: number | 'inf';
-  truncation: 'auto' | 'disabled';
-  prompt: string | null;
-  tracing: string | null;
-  expires_at: number;
-  include: string[] | null;
-}
-
-// Turn detection can be either server_vad (simple) or semantic_vad (advanced with eagerness)
-export interface ServerVADTurnDetection {
-  type: 'server_vad';
-  threshold?: number;
-  prefix_padding_ms?: number;
-  silence_duration_ms?: number;
-  idle_timeout_ms?: number | null;
-  create_response?: boolean;
-  interrupt_response?: boolean;
-}
-
-export interface SemanticVADTurnDetection {
-  type: 'semantic_vad';
-  eagerness?: 'low' | 'medium' | 'high' | 'auto';
-  create_response?: boolean;
-  interrupt_response?: boolean;
-}
-
-export type TurnDetection = ServerVADTurnDetection | SemanticVADTurnDetection;
-
-export interface Tool {
-  type: 'function';
-  name: string;
-  description?: string;
-  parameters?: Record<string, any>;
-}
-
-export interface ConversationItem {
-  id?: string;
-  type: 'message' | 'function_call' | 'function_call_output';
-  object?: 'realtime.item';
-  status?: 'completed' | 'in_progress' | 'incomplete';
-  role?: 'user' | 'assistant' | 'system';
-  content?: ContentPart[];
-  call_id?: string;
-  name?: string;
-  arguments?: string;
-  output?: string;
-}
-
-// Specific types for different conversation items
-export interface MessageItem extends ConversationItem {
-  type: 'message';
-  role: 'user' | 'assistant' | 'system';
-  content: ContentPart[];
-}
-
-export interface FunctionCallItem extends ConversationItem {
-  type: 'function_call';
-  call_id: string;
-  name: string;
-  arguments: string;
-}
-
-export interface FunctionCallOutputItem extends ConversationItem {
-  type: 'function_call_output';
-  call_id: string;
-  output: string;
-}
-
-export interface ContentPart {
-  type: 'text' | 'audio' | 'input_text' | 'input_audio';
-  text?: string;
-  audio?: string; // base64-encoded
-  transcript?: string;
-}
-
-export interface ResponseConfig {
-  modalities?: ('text' | 'audio')[];
-  instructions?: string;
-  voice?: string;
-  output_audio_format?: 'pcm16' | 'g711_ulaw' | 'g711_alaw';
-  tools?: Tool[];
-  tool_choice?: 'auto' | 'none' | 'required';
-  temperature?: number;
-  max_output_tokens?: number | 'inf';
-}
-
-export interface Response {
-  id: string;
-  object: 'realtime.response';
-  status: 'in_progress' | 'completed' | 'cancelled' | 'failed' | 'incomplete';
-  status_details?: {
-    type: 'completed' | 'cancelled' | 'incomplete' | 'failed';
-    reason?: string;
-    error?: {
-      type: string;
-      code?: string;
-    };
-  } | null;
-  output: ConversationItem[];
-  conversation_id?: string | null;
-  output_modalities?: ('text' | 'audio')[];
-  max_output_tokens?: number | 'inf';
-  audio?: {
-    output: AudioOutputConfig;
-  };
-  usage?: {
-    total_tokens: number;
-    input_tokens: number;
-    output_tokens: number;
-    input_token_details?: {
-      cached_tokens?: number;
-      text_tokens?: number;
-      image_tokens?: number;
-      audio_tokens?: number;
-    };
-    output_token_details?: {
-      text_tokens?: number;
-      audio_tokens?: number;
-    };
-  } | null;
-  metadata?: any | null;
-}
-
-// ============================================================================
-// Session State
-// ============================================================================
-
-export interface RealtimeSession {
-  id: string;
-  session: Session;
-  conversationItems: ConversationItem[];
-  inputAudioBuffer: number[];
-  currentResponse: Response | null;
-  audioStartMs: number;
-  // Store active streams so they can be aborted on cancel
-  currentContentStream?: GraphTypes.ContentStream | null;
-  currentTTSStream?: GraphTypes.TTSOutputStream | null;
-}
diff --git a/realtime-service/src/types/settings.ts b/realtime-service/src/types/settings.ts
deleted file mode 100644
index 4fd332e..0000000
--- a/realtime-service/src/types/settings.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Maps OpenAI eagerness levels to AssemblyAI turn detection settings
- * Based on AssemblyAI's recommended configurations for different use cases
- */
-
-export interface AssemblyAITurnDetectionSettings {
-  endOfTurnConfidenceThreshold: number;
-  minEndOfTurnSilenceWhenConfident: number;
-  maxTurnSilence: number;
-  description: string;
-}
-
-/**
- * Get AssemblyAI turn detection settings for a given eagerness level
- * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
- * @returns AssemblyAI turn detection settings including threshold values and description
- */
-export function getAssemblyAISettingsForEagerness(
-  eagerness: 'low' | 'medium' | 'high' = 'medium'
-): AssemblyAITurnDetectionSettings {
-  switch (eagerness) {
-    case 'high': // Aggressive - VERY responsive
-      return {
-        endOfTurnConfidenceThreshold: 0.4,
-        minEndOfTurnSilenceWhenConfident: 160,
-        maxTurnSilence: 320,
-        description: 'Aggressive - VERY quick responses, ideal for rapid Q&A (Agent Assist, IVR)',
-      };
-    case 'medium': // Balanced (default)
-      return {
-        endOfTurnConfidenceThreshold: 0.4,
-        minEndOfTurnSilenceWhenConfident: 400,
-        maxTurnSilence: 1280,
-        description: 'Balanced - Natural conversation flow (Customer Support, Tech Support)',
-      };
-    case 'low': // Conservative - VERY patient
-      return {
-        endOfTurnConfidenceThreshold: 0.7,
-        minEndOfTurnSilenceWhenConfident: 800,
-        maxTurnSilence: 3000,
-        description: 'Conservative - VERY patient, allows long thinking pauses (Complex inquiries)',
-      };
-  }
-}
-
diff --git a/realtime-service/tsconfig.test.json b/realtime-service/tsconfig.test.json
deleted file mode 100644
index 96174c8..0000000
--- a/realtime-service/tsconfig.test.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "extends": "./src/tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "types": ["node", "jest"],
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "__tests__/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}
-
diff --git a/realtime-service/yarn.lock b/realtime-service/yarn.lock
deleted file mode 100644
index 42d12b0..0000000
--- a/realtime-service/yarn.lock
+++ /dev/null
@@ -1,8 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-ws@^8.18.3:
-  version "8.18.3"
-  resolved "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz"
-  integrity sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==

From 01908e7d8e28e50ad0873e67ca0fc6d7de68e53f Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:13:45 -0800
Subject: [PATCH 04/49] remove japanese and add all languages supported by
 assembly realtime streaing

---
 backend/config/languages.ts                   | 186 ++++++++++++++----
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |   3 +-
 2 files changed, 147 insertions(+), 42 deletions(-)

diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index 0ce9e97..3695913 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -57,6 +57,40 @@ export interface LanguageConfig {
  * - Cultural context and example topics
  */
 export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
+  en: {
+    code: 'en',
+    name: 'English',
+    nativeName: 'English',
+    flag: '🇺🇸',
+    sttLanguageCode: 'en-US',
+    ttsConfig: {
+      speakerId: 'Ashley',
+      modelId: 'inworld-tts-1.5',
+      speakingRate: 1,
+      temperature: 1.1,
+      languageCode: 'en-US',
+    },
+    teacherPersona: {
+      name: 'Ms. Sarah Mitchell',
+      age: 34,
+      nationality: 'American (New York)',
+      description:
+        'a 34 year old New Yorker who loves teaching English through everyday conversations and pop culture',
+    },
+    exampleTopics: [
+      'New York City life',
+      'American movies and TV shows',
+      'sports and outdoor activities',
+      'American idioms and slang',
+      'travel across the United States',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in English
+- Explain common idioms and phrasal verbs when they come up naturally
+- Help with pronunciation of tricky English sounds
+- Vary complexity based on the user's level`,
+  },
+
   es: {
     code: 'es',
     name: 'Spanish',
@@ -66,8 +100,8 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     ttsConfig: {
       speakerId: 'Diego',
       modelId: 'inworld-tts-1',
-      speakingRate: 1,
-      temperature: 0.7,
+      speakingRate: 1.1,
+      temperature: 1.1,
       languageCode: 'es-MX',
     },
     teacherPersona: {
@@ -90,53 +124,17 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
 - Vary complexity based on the user's level`,
   },
 
-  ja: {
-    code: 'ja',
-    name: 'Japanese',
-    nativeName: '日本語',
-    flag: '🇯🇵',
-    sttLanguageCode: 'ja-JP', // Japanese
-    ttsConfig: {
-      speakerId: 'Asuka',
-      modelId: 'inworld-tts-1',
-      speakingRate: 0.95,
-      temperature: 0.7,
-      languageCode: 'ja-JP',
-    },
-    teacherPersona: {
-      name: '田中先生 (Tanaka-sensei)',
-      age: 42,
-      nationality: 'Japanese (Tokyo)',
-      description:
-        'a 42 year old Japanese teacher from Tokyo who loves sharing Japanese culture and language',
-    },
-    exampleTopics: [
-      'Tokyo neighborhoods',
-      'Japanese cuisine and izakaya culture',
-      'anime and manga',
-      'traditional arts like calligraphy and tea ceremony',
-      'Japanese music from enka to J-pop',
-      'seasonal festivals (matsuri)',
-    ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in Japanese
-- Explain the difference between casual and polite forms when relevant
-- Introduce kanji gradually with furigana explanations when helpful
-- Mention cultural context behind expressions (e.g., why certain phrases are used)
-- Use romanji in parentheses when introducing new vocabulary`,
-  },
-
   fr: {
     code: 'fr',
     name: 'French',
     nativeName: 'Français',
     flag: '🇫🇷',
-    sttLanguageCode: 'fr-FR', // French
+    sttLanguageCode: 'fr-FR',
     ttsConfig: {
       speakerId: 'Alain',
       modelId: 'inworld-tts-1',
       speakingRate: 1,
-      temperature: 0.7,
+      temperature: 1.1,
       languageCode: 'fr-FR',
     },
     teacherPersona: {
@@ -161,6 +159,114 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
 - Share cultural context about French expressions and idioms
 - Mention pronunciation tips for tricky French sounds`,
   },
+
+  de: {
+    code: 'de',
+    name: 'German',
+    nativeName: 'Deutsch',
+    flag: '🇩🇪',
+    sttLanguageCode: 'de-DE',
+    ttsConfig: {
+      speakerId: 'Josef',
+      modelId: 'inworld-tts-1',
+      speakingRate: 1,
+      temperature: 0.7,
+      languageCode: 'de-DE',
+    },
+    teacherPersona: {
+      name: 'Herr Klaus Weber',
+      age: 45,
+      nationality: 'German (Berlin)',
+      description:
+        'a 45 year old Berliner who enjoys teaching German through history, philosophy, and modern culture',
+    },
+    exampleTopics: [
+      'Berlin history and reunification',
+      'German beer and food culture',
+      'classical music and composers',
+      'German engineering and innovation',
+      'traveling through Bavaria and the Alps',
+      'German literature from Goethe to modern authors',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in German
+- Help with noun genders (der, die, das) and case endings
+- Explain compound word formation when relevant
+- Share cultural context about German expressions
+- Help with word order in main and subordinate clauses`,
+  },
+
+  it: {
+    code: 'it',
+    name: 'Italian',
+    nativeName: 'Italiano',
+    flag: '🇮🇹',
+    sttLanguageCode: 'it-IT',
+    ttsConfig: {
+      speakerId: 'Orietta',
+      modelId: 'inworld-tts-1',
+      speakingRate: 1,
+      temperature: 1.1,
+      languageCode: 'it-IT',
+    },
+    teacherPersona: {
+      name: 'Signora Maria Rossi',
+      age: 40,
+      nationality: 'Italian (Roman)',
+      description:
+        'a 40 year old Roman who is passionate about Italian art, cuisine, and la dolce vita',
+    },
+    exampleTopics: [
+      'Roman history and ancient sites',
+      'Italian cuisine and regional specialties',
+      'Renaissance art and architecture',
+      'Italian cinema and neorealism',
+      'fashion and design in Milan',
+      'Italian music from opera to modern pop',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in Italian
+- Help with verb conjugations and tenses
+- Explain the use of formal (Lei) vs informal (tu) when relevant
+- Share cultural context about Italian expressions and gestures
+- Mention regional variations when appropriate`,
+  },
+
+  pt: {
+    code: 'pt',
+    name: 'Portuguese',
+    nativeName: 'Português',
+    flag: '🇧🇷',
+    sttLanguageCode: 'pt-BR', // Brazilian Portuguese
+    ttsConfig: {
+      speakerId: 'Heitor',
+      modelId: 'inworld-tts-1',
+      speakingRate: 1,
+      temperature: 0.7,
+      languageCode: 'pt-BR',
+    },
+    teacherPersona: {
+      name: 'Senhor João Silva',
+      age: 36,
+      nationality: 'Brazilian (Carioca)',
+      description:
+        'a 36 year old Carioca from Rio de Janeiro who loves sharing Brazilian culture, music, and the joy of Portuguese',
+    },
+    exampleTopics: [
+      'Rio de Janeiro and Brazilian beaches',
+      'Brazilian music from bossa nova to funk',
+      'Carnival and Brazilian festivals',
+      'Brazilian cuisine and churrasco',
+      'football (soccer) culture',
+      'the Amazon and Brazilian nature',
+    ],
+    promptInstructions: `
+- Gently correct the user if they make mistakes in Portuguese
+- Use natural Brazilian Portuguese expressions when appropriate
+- Explain differences between Brazilian and European Portuguese when relevant
+- Help with verb conjugations and the subjunctive mood
+- Share cultural context about Brazilian expressions and slang`,
+  },
 };
 
 /**
diff --git a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
index 7dd0bec..0e16b1d 100644
--- a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -372,7 +372,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       ? 'universal-streaming-english'
       : 'universal-streaming-multilingual';
 
-    const languageCode = language === 'en' ? 'en' : 'multi';
 
     const params = new URLSearchParams({
       sample_rate: this.sampleRate.toString(),
@@ -382,7 +381,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
       max_turn_silence: maxSilence.toString(),
       speech_model: speechModel,
-      language: languageCode
+      language_detection: 'true'.toString()
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;

From 50112ccf9bf89251637d2501a8b5b272a0ab6b57 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:53:31 -0800
Subject: [PATCH 05/49] 0.9 working but want to improve quality and latency

---
 backend/graphs/conversation-graph.ts          |   2 +-
 backend/graphs/introduction-state-graph.ts    | 215 ------------------
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  71 +++---
 .../nodes/dialog_prompt_builder_node.ts       |  12 +-
 backend/helpers/audio_utils.ts                |  33 ++-
 backend/helpers/connection-manager.ts         |  86 +------
 .../helpers/introduction-state-processor.ts   | 144 ------------
 backend/helpers/prompt-templates.ts           |  46 +---
 backend/server.ts                             |  37 +--
 backend/types/index.ts                        |   2 -
 backend/types/settings.ts                     |  10 +-
 frontend/src/context/AppContext.tsx           |  18 ++
 12 files changed, 99 insertions(+), 577 deletions(-)
 delete mode 100644 backend/graphs/introduction-state-graph.ts
 delete mode 100644 backend/helpers/introduction-state-processor.ts

diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 5f64f43..9e31917 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -93,7 +93,7 @@ export class ConversationGraphWrapper {
     const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
 
     // AssemblyAI STT with built-in VAD
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness('medium');
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness('high');
     const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
       id: `assembly-ai-stt-ws-node${postfix}`,
       config: {
diff --git a/backend/graphs/introduction-state-graph.ts b/backend/graphs/introduction-state-graph.ts
deleted file mode 100644
index bc1e817..0000000
--- a/backend/graphs/introduction-state-graph.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-import 'dotenv/config';
-import {
-  GraphBuilder,
-  CustomNode,
-  ProcessContext,
-  RemoteLLMChatNode,
-  Graph,
-} from '@inworld/runtime/graph';
-import { GraphTypes } from '@inworld/runtime/common';
-import { PromptBuilder } from '@inworld/runtime/primitives/llm';
-import { introductionStatePromptTemplate } from '../helpers/prompt-templates.js';
-import {
-  LanguageConfig,
-  getLanguageConfig,
-  DEFAULT_LANGUAGE_CODE,
-} from '../config/languages.js';
-
-type IntroductionStateLevel = 'beginner' | 'intermediate' | 'advanced' | '';
-
-export interface IntroductionState {
-  name: string;
-  level: IntroductionStateLevel;
-  goal: string;
-  timestamp: string;
-}
-
-class IntroductionPromptBuilderNode extends CustomNode {
-  async process(
-    _context: ProcessContext,
-    input: GraphTypes.Content | Record<string, unknown>
-  ) {
-    const builder = await PromptBuilder.create(introductionStatePromptTemplate);
-    const renderedPrompt = await builder.build(input as Record<string, unknown>);
-    return renderedPrompt;
-  }
-}
-
-class TextToChatRequestNode extends CustomNode {
-  process(_context: ProcessContext, renderedPrompt: string) {
-    return new GraphTypes.LLMChatRequest({
-      messages: [{ role: 'user', content: renderedPrompt }],
-    });
-  }
-}
-
-/**
- * Normalize level strings from various languages to standard values
- * Supports: English, Spanish, Japanese, French (and more can be added)
- */
-function normalizeLevel(level: unknown): IntroductionStateLevel {
-  if (typeof level !== 'string') return '';
-  const lower = level
-    .trim()
-    .toLowerCase()
-    .replace(/[.!?,;:]+$/g, '');
-
-  const mapping: Record<string, IntroductionStateLevel> = {
-    // English
-    beginner: 'beginner',
-    intermediate: 'intermediate',
-    advanced: 'advanced',
-    // Spanish
-    principiante: 'beginner',
-    intermedio: 'intermediate',
-    avanzado: 'advanced',
-    // French
-    débutant: 'beginner',
-    debutant: 'beginner',
-    intermédiaire: 'intermediate',
-    intermediaire: 'intermediate',
-    avancé: 'advanced',
-    avance: 'advanced',
-    // Japanese (romanji)
-    shoshinsha: 'beginner',
-    chūkyū: 'intermediate',
-    chuukyuu: 'intermediate',
-    jōkyū: 'advanced',
-    joukyuu: 'advanced',
-    // Japanese (hiragana/katakana - common responses)
-    初心者: 'beginner',
-    中級: 'intermediate',
-    上級: 'advanced',
-    // Additional variations
-    basic: 'beginner',
-    elementary: 'beginner',
-    beginning: 'beginner',
-    middle: 'intermediate',
-    medium: 'intermediate',
-    expert: 'advanced',
-    fluent: 'advanced',
-  };
-
-  return mapping[lower] || '';
-}
-
-class IntroductionStateParserNode extends CustomNode {
-  process(_context: ProcessContext, input: GraphTypes.Content) {
-    try {
-      const content =
-        (input &&
-          typeof input === 'object' &&
-          'content' in input &&
-          (input as { content?: unknown }).content) ||
-        input;
-      const textContent =
-        typeof content === 'string' ? content : JSON.stringify(content);
-      console.log(
-        'IntroductionStateParserNode - Raw LLM response:',
-        textContent
-      );
-
-      const jsonMatch = textContent.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        console.log('IntroductionStateParserNode - Parsed JSON:', parsed);
-
-        const name = typeof parsed.name === 'string' ? parsed.name.trim() : '';
-        const level = normalizeLevel(parsed.level);
-        const goal = typeof parsed.goal === 'string' ? parsed.goal.trim() : '';
-        const state: IntroductionState = {
-          name,
-          level,
-          goal,
-          timestamp: new Date().toISOString(),
-        };
-        console.log('IntroductionStateParserNode - Returning state:', state);
-        return state;
-      }
-    } catch (error) {
-      console.error('Failed to parse introduction state JSON:', error);
-    }
-
-    const fallback: IntroductionState = {
-      name: '',
-      level: '',
-      goal: '',
-      timestamp: new Date().toISOString(),
-    };
-    console.log('IntroductionStateParserNode - Returning fallback state');
-    return fallback;
-  }
-}
-
-/**
- * Create an introduction state extraction graph for a specific language
- */
-function createIntroductionStateGraphForLanguage(
-  languageConfig: LanguageConfig
-): Graph {
-  const apiKey = process.env.INWORLD_API_KEY;
-  if (!apiKey) {
-    throw new Error('INWORLD_API_KEY environment variable is required');
-  }
-
-  const promptBuilderNode = new IntroductionPromptBuilderNode({
-    id: 'introduction-prompt-builder',
-  });
-  const textToChatRequestNode = new TextToChatRequestNode({
-    id: 'text-to-chat-request',
-  });
-  const llmNode = new RemoteLLMChatNode({
-    id: 'llm_node',
-    provider: 'openai',
-    modelName: 'gpt-4o-mini',
-    stream: false,
-  });
-  const parserNode = new IntroductionStateParserNode({
-    id: 'introduction-state-parser',
-  });
-
-  const executor = new GraphBuilder({
-    id: `introduction-state-graph-${languageConfig.code}`,
-    enableRemoteConfig: false,
-  })
-    .addNode(promptBuilderNode)
-    .addNode(textToChatRequestNode)
-    .addNode(llmNode)
-    .addNode(parserNode)
-    .addEdge(promptBuilderNode, textToChatRequestNode)
-    .addEdge(textToChatRequestNode, llmNode)
-    .addEdge(llmNode, parserNode)
-    .setStartNode(promptBuilderNode)
-    .setEndNode(parserNode)
-    .build();
-
-  return executor;
-}
-
-// Cache for language-specific introduction state graphs
-const introductionStateGraphCache = new Map<string, Graph>();
-
-/**
- * Get or create an introduction state graph for a specific language
- */
-export function getIntroductionStateGraph(
-  languageCode: string = DEFAULT_LANGUAGE_CODE
-): Graph {
-  if (!introductionStateGraphCache.has(languageCode)) {
-    const languageConfig = getLanguageConfig(languageCode);
-    console.log(
-      `Creating introduction state graph for language: ${languageConfig.name} (${languageCode})`
-    );
-    const graph = createIntroductionStateGraphForLanguage(languageConfig);
-    introductionStateGraphCache.set(languageCode, graph);
-  }
-
-  return introductionStateGraphCache.get(languageCode)!;
-}
-
-/**
- * Legacy function for backwards compatibility
- */
-export function createIntroductionStateGraph(): Graph {
-  return getIntroductionStateGraph(DEFAULT_LANGUAGE_CODE);
-}
diff --git a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
index 0e16b1d..596c392 100644
--- a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -19,7 +19,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { Connection } from '../../types/index.js';
 // Settings imported but used via constructor config
 // import { getAssemblyAISettingsForEagerness } from '../../types/settings.js';
-import { float32ToPCM16 } from '../../helpers/audio_utils.js';
+import { audioDataToPCM16 } from '../../helpers/audio_utils.js';
 
 /**
  * Configuration interface for AssemblyAISTTWebSocketNode
@@ -59,11 +59,9 @@ class AssemblyAISession {
   private lastActivityTime: number = Date.now();
   private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
 
-  // Track completed turns to prevent duplicate processing
+  // Track completed turns to prevent duplicate processing (content-based, not time-based)
   private lastCompletedTranscript: string = '';
   private newSpeechReceived: boolean = false;
-  private lastTurnTimestamp: number = 0;
-  private readonly TURN_DEBOUNCE_MS = 500; // Minimum time between accepting turns
 
   constructor(
     public readonly sessionId: string,
@@ -231,14 +229,19 @@ class AssemblyAISession {
   /**
    * Check if a turn should be accepted or rejected as duplicate
    * Returns true if the turn is valid and should be processed
+   *
+   * Note: We use content-based deduplication instead of time-based debouncing
+   * to avoid adding latency while still preventing duplicate processing.
    */
   public shouldAcceptTurn(transcript: string): boolean {
-    const now = Date.now();
+    // If new speech was received since last turn, always accept
+    if (this.newSpeechReceived) {
+      return true;
+    }
 
-    // Check debounce - if a turn was just completed, reject
-    if (this.lastTurnTimestamp > 0 && now - this.lastTurnTimestamp < this.TURN_DEBOUNCE_MS) {
-      console.log(`[AssemblyAI] Rejecting turn - within debounce period (${now - this.lastTurnTimestamp}ms)`);
-      return false;
+    // No new speech - check for duplicate content
+    if (!this.lastCompletedTranscript) {
+      return true; // No previous turn to compare against
     }
 
     // Normalize transcripts for comparison (lowercase, remove punctuation, trim)
@@ -248,19 +251,14 @@ class AssemblyAISession {
     const normalizedNew = normalizeText(transcript);
     const normalizedLast = normalizeText(this.lastCompletedTranscript);
 
-    // If no new speech was received since last turn, check for duplicate content
-    if (!this.newSpeechReceived && this.lastCompletedTranscript) {
-      // Check if transcripts are similar (allowing for minor formatting differences)
-      const isSimilar = normalizedNew === normalizedLast ||
-                       normalizedNew.includes(normalizedLast) ||
-                       normalizedLast.includes(normalizedNew);
-
-      if (isSimilar) {
-        console.log(`[AssemblyAI] Rejecting turn - duplicate content without new speech`);
-        console.log(`  Last: "${this.lastCompletedTranscript.substring(0, 50)}..."`);
-        console.log(`  New:  "${transcript.substring(0, 50)}..."`);
-        return false;
-      }
+    // Check if transcripts are similar (allowing for minor formatting differences)
+    const isSimilar = normalizedNew === normalizedLast ||
+                     normalizedNew.includes(normalizedLast) ||
+                     normalizedLast.includes(normalizedNew);
+
+    if (isSimilar) {
+      console.log(`[AssemblyAI] Rejecting turn - duplicate content without new speech`);
+      return false;
     }
 
     return true;
@@ -270,10 +268,8 @@ class AssemblyAISession {
    * Mark that a turn was completed - store for deduplication
    */
   public markTurnCompleted(transcript: string): void {
-    this.lastTurnTimestamp = Date.now();
     this.lastCompletedTranscript = transcript;
     this.newSpeechReceived = false; // Reset for next turn
-    console.log(`[AssemblyAI] Turn completed, transcript stored for deduplication`);
   }
 
   /**
@@ -299,7 +295,8 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
   private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
 
   private sessions: Map<string, AssemblyAISession> = new Map();
-  private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
+  // Reduced from 2000ms for faster response when audio ends before turn detection
+  private readonly TURN_COMPLETION_TIMEOUT_MS = 1200;
   private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
 
   constructor(props: { id?: string; config: AssemblyAISTTWebSocketNodeConfig }) {
@@ -312,15 +309,18 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       throw new Error('AssemblyAISTTWebSocketNode requires a connections object.');
     }
 
+    // Optimized defaults for lower latency voice-to-voice interaction:
+    // - Higher confidence threshold (0.5) detects turns faster with more certainty
+    // - Lower silence thresholds (300ms/900ms) reduce wait time after speech ends
     super({
       id: nodeProps.id || 'assembly-ai-stt-ws-node',
       executionConfig: {
         sampleRate: config.sampleRate || 16000,
         formatTurns: config.formatTurns !== false,
-        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold || 0.4,
+        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold || 0.5,
         minEndOfTurnSilenceWhenConfident:
-          config.minEndOfTurnSilenceWhenConfident || 400,
-        maxTurnSilence: config.maxTurnSilence || 1280,
+          config.minEndOfTurnSilenceWhenConfident || 300,
+        maxTurnSilence: config.maxTurnSilence || 900,
         language: config.language || 'es',
       },
     });
@@ -330,10 +330,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.sampleRate = config.sampleRate || 16000;
     this.formatTurns = config.formatTurns !== false;
     this.endOfTurnConfidenceThreshold =
-      config.endOfTurnConfidenceThreshold || 0.4;
+      config.endOfTurnConfidenceThreshold || 0.5;
     this.minEndOfTurnSilenceWhenConfident =
-      config.minEndOfTurnSilenceWhenConfident || 400;
-    this.maxTurnSilence = config.maxTurnSilence || 1280;
+      config.minEndOfTurnSilenceWhenConfident || 300;
+    this.maxTurnSilence = config.maxTurnSilence || 900;
     this.defaultLanguage = config.language || 'es';
 
     const defaultModel = this.defaultLanguage === 'en'
@@ -614,14 +614,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
               continue;
             }
 
-            const float32Data = Array.isArray(audioData)
-              ? new Float32Array(audioData)
-              : audioData;
-
             audioChunkCount++;
-            totalAudioSamples += float32Data.length;
+            totalAudioSamples += audioData.length;
 
-            const pcm16Data = float32ToPCM16(float32Data);
+            // Convert directly to PCM16 without intermediate Float32Array allocation
+            const pcm16Data = audioDataToPCM16(audioData);
             session?.sendAudio(pcm16Data);
           }
         } catch (error) {
diff --git a/backend/graphs/nodes/dialog_prompt_builder_node.ts b/backend/graphs/nodes/dialog_prompt_builder_node.ts
index 036f079..d035b35 100644
--- a/backend/graphs/nodes/dialog_prompt_builder_node.ts
+++ b/backend/graphs/nodes/dialog_prompt_builder_node.ts
@@ -4,7 +4,7 @@
  * This node is specifically designed for the language learning app and:
  * - Receives the current conversation state
  * - Applies the language-specific prompt template
- * - Uses Jinja to render the prompt with conversation history and introduction state
+ * - Uses Jinja to render the prompt with conversation history
  * - Returns a formatted LLMChatRequest for the LLM node
  */
 
@@ -54,15 +54,6 @@ export class DialogPromptBuilderNode extends CustomNode {
     const lastMessage = messages[messages.length - 1];
     const currentInput = lastMessage?.role === 'user' ? lastMessage.content : '';
 
-    // Get introduction state
-    const introductionState = state.introductionState || {
-      name: '',
-      level: '',
-      goal: '',
-      timestamp: '',
-    };
-
-    console.log('[DialogPromptBuilder] Introduction state:', JSON.stringify(introductionState));
     console.log('[DialogPromptBuilder] Language:', langConfig.name);
     console.log('[DialogPromptBuilder] Messages in history:', historyMessages.length);
 
@@ -72,7 +63,6 @@ export class DialogPromptBuilderNode extends CustomNode {
         content: m.content,
       })),
       current_input: currentInput,
-      introduction_state: introductionState,
       ...templateVars,
     };
 
diff --git a/backend/helpers/audio_utils.ts b/backend/helpers/audio_utils.ts
index 6084f08..de69e95 100644
--- a/backend/helpers/audio_utils.ts
+++ b/backend/helpers/audio_utils.ts
@@ -71,14 +71,24 @@ export function debugSaveAudio(sessionId: string, sampleRate: number = 16000): s
 
 /**
  * Log audio stats for debugging
+ * Note: Uses loop instead of spread operator to avoid stack overflow on large arrays
  */
 export function debugLogAudioStats(sessionId: string, float32Data: Float32Array): void {
   if (!DEBUG_AUDIO) return;
 
-  const min = Math.min(...float32Data);
-  const max = Math.max(...float32Data);
-  const avg = float32Data.reduce((a, b) => a + b, 0) / float32Data.length;
-  const nonZero = float32Data.filter(v => Math.abs(v) > 0.001).length;
+  // Calculate stats using loops to avoid blocking with large arrays
+  let min = Infinity;
+  let max = -Infinity;
+  let sum = 0;
+  let nonZero = 0;
+  for (let i = 0; i < float32Data.length; i++) {
+    const v = float32Data[i];
+    if (v < min) min = v;
+    if (v > max) max = v;
+    sum += v;
+    if (Math.abs(v) > 0.001) nonZero++;
+  }
+  const avg = sum / float32Data.length;
 
   console.log(`[AudioDebug] Session ${sessionId.slice(-8)}: samples=${float32Data.length}, min=${min.toFixed(4)}, max=${max.toFixed(4)}, avg=${avg.toFixed(4)}, nonZero=${nonZero}/${float32Data.length}`);
 }
@@ -142,6 +152,21 @@ export function float32ToPCM16(float32Data: Float32Array): Int16Array {
   return pcm16;
 }
 
+/**
+ * Convert number[] or Float32Array audio data to Int16Array (PCM16)
+ * This is an optimized version that handles both types to avoid
+ * intermediate allocations in the audio pipeline.
+ */
+export function audioDataToPCM16(audioData: number[] | Float32Array): Int16Array {
+  const pcm16 = new Int16Array(audioData.length);
+  for (let i = 0; i < audioData.length; i++) {
+    // Clamp to [-1, 1] range and convert to Int16 range [-32768, 32767]
+    const s = Math.max(-1, Math.min(1, audioData[i]));
+    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+  }
+  return pcm16;
+}
+
 /**
  * Convert Int16Array (PCM16) to Float32Array
  */
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index 219cd17..d060a3a 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -20,7 +20,6 @@ import {
   DEFAULT_LANGUAGE_CODE,
   LanguageConfig,
 } from '../config/languages.js';
-import type { IntroductionState } from './introduction-state-processor.js';
 
 export class ConnectionManager {
   private sessionId: string;
@@ -33,15 +32,10 @@ export class ConnectionManager {
   private languageCode: string;
   private languageConfig: LanguageConfig;
 
-  // Callbacks for flashcard and introduction state processing
+  // Callback for flashcard processing
   private flashcardCallback:
     | ((messages: Array<{ role: string; content: string }>) => Promise<void>)
     | null = null;
-  private introductionStateCallback:
-    | ((
-        messages: Array<{ role: string; content: string }>
-      ) => Promise<IntroductionState | null>)
-    | null = null;
 
   constructor(
     sessionId: string,
@@ -68,7 +62,6 @@ export class ConnectionManager {
         targetLanguage: this.languageConfig.name,
         languageCode: languageCode,
         voiceId: this.languageConfig.ttsConfig.speakerId,
-        introductionState: { name: '', level: '', goal: '', timestamp: '' },
         output_modalities: ['audio', 'text'],
       },
       multimodalStreamManager: this.multimodalStreamManager,
@@ -190,9 +183,6 @@ export class ConnectionManager {
               text: transcription.trim(),
               timestamp: Date.now(),
             });
-
-            // Trigger introduction state extraction
-            this.triggerIntroductionStateExtraction();
           }
         },
 
@@ -209,7 +199,6 @@ export class ConnectionManager {
               text: transcription.trim(),
               timestamp: Date.now(),
             });
-            this.triggerIntroductionStateExtraction();
           }
         },
 
@@ -217,12 +206,13 @@ export class ConnectionManager {
         ContentStream: async (streamData: unknown) => {
           const stream = streamData as GraphTypes.ContentStream;
           console.log('[ConnectionManager] Processing LLM ContentStream...');
-          let currentResponse = '';
+          // Use array + join instead of string concatenation for O(n) vs O(n²)
+          const responseChunks: string[] = [];
 
           for await (const chunk of stream) {
             if (this.isDestroyed) break;
             if (chunk.text) {
-              currentResponse += chunk.text;
+              responseChunks.push(chunk.text);
               this.sendToClient({
                 type: 'llm_response_chunk',
                 text: chunk.text,
@@ -231,6 +221,7 @@ export class ConnectionManager {
             }
           }
 
+          const currentResponse = responseChunks.join('');
           if (currentResponse.trim()) {
             llmResponse = currentResponse;
             console.log(
@@ -331,9 +322,10 @@ export class ConnectionManager {
       debugLogAudioStats(this.sessionId, float32Data);
       debugAddAudioChunk(this.sessionId, float32Data);
 
-      // Push to multimodal stream
+      // Push to multimodal stream - pass Float32Array directly,
+      // MultimodalStreamManager will handle conversion when needed
       this.multimodalStreamManager.pushAudio({
-        data: Array.from(float32Data),
+        data: float32Data,
         sampleRate: INPUT_SAMPLE_RATE,
       });
     } catch (error) {
@@ -432,42 +424,6 @@ export class ConnectionManager {
     });
   }
 
-  /**
-   * Trigger introduction state extraction
-   */
-  private triggerIntroductionStateExtraction(): void {
-    if (!this.introductionStateCallback) return;
-
-    const connection = this.connections[this.sessionId];
-    if (!connection) return;
-
-    // Skip if introduction is already complete
-    const intro = connection.state.introductionState;
-    if (intro.name && intro.level && intro.goal) {
-      return;
-    }
-
-    const recentMessages = connection.state.messages.slice(-6).map((m) => ({
-      role: m.role,
-      content: m.content,
-    }));
-
-    this.introductionStateCallback(recentMessages)
-      .then((state) => {
-        if (state) {
-          connection.state.introductionState = state;
-          this.sendToClient({
-            type: 'introduction_state_updated',
-            introduction_state: state,
-            timestamp: Date.now(),
-          });
-        }
-      })
-      .catch((error) => {
-        console.error('[ConnectionManager] Introduction state error:', error);
-      });
-  }
-
   // ============================================================
   // Public API (compatible with AudioProcessor)
   // ============================================================
@@ -480,14 +436,6 @@ export class ConnectionManager {
     this.flashcardCallback = callback;
   }
 
-  setIntroductionStateCallback(
-    callback: (
-      messages: Array<{ role: string; content: string }>
-    ) => Promise<IntroductionState | null>
-  ): void {
-    this.introductionStateCallback = callback;
-  }
-
   getConversationState(): { messages: Array<{ role: string; content: string; timestamp: string }> } {
     const connection = this.connections[this.sessionId];
     return {
@@ -500,18 +448,6 @@ export class ConnectionManager {
     };
   }
 
-  getIntroductionState(): IntroductionState {
-    const connection = this.connections[this.sessionId];
-    return (
-      connection?.state.introductionState || {
-        name: '',
-        level: '',
-        goal: '',
-        timestamp: '',
-      }
-    );
-  }
-
   getLanguageCode(): string {
     return this.languageCode;
   }
@@ -552,12 +488,6 @@ export class ConnectionManager {
     const connection = this.connections[this.sessionId];
     if (connection) {
       connection.state.messages = [];
-      connection.state.introductionState = {
-        name: '',
-        level: '',
-        goal: '',
-        timestamp: '',
-      };
       connection.state.interactionId = '';
     }
     console.log('[ConnectionManager] Conversation reset');
diff --git a/backend/helpers/introduction-state-processor.ts b/backend/helpers/introduction-state-processor.ts
deleted file mode 100644
index ea465fe..0000000
--- a/backend/helpers/introduction-state-processor.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { Graph } from '@inworld/runtime/graph';
-import { GraphTypes } from '@inworld/runtime/common';
-import { getIntroductionStateGraph } from '../graphs/introduction-state-graph.js';
-import {
-  LanguageConfig,
-  getLanguageConfig,
-  DEFAULT_LANGUAGE_CODE,
-} from '../config/languages.js';
-
-export type IntroductionStateLevel =
-  | 'beginner'
-  | 'intermediate'
-  | 'advanced'
-  | '';
-
-export interface IntroductionState {
-  name: string;
-  level: IntroductionStateLevel;
-  goal: string;
-  timestamp: string;
-}
-
-export interface ConversationMessage {
-  role: string;
-  content: string;
-}
-
-export class IntroductionStateProcessor {
-  private state: IntroductionState = {
-    name: '',
-    level: '',
-    goal: '',
-    timestamp: '',
-  };
-  private executor: Graph;
-  private languageCode: string = DEFAULT_LANGUAGE_CODE;
-  private languageConfig: LanguageConfig;
-
-  constructor(languageCode: string = DEFAULT_LANGUAGE_CODE) {
-    this.languageCode = languageCode;
-    this.languageConfig = getLanguageConfig(languageCode);
-    this.executor = getIntroductionStateGraph(languageCode);
-  }
-
-  /**
-   * Update the language for this processor
-   */
-  setLanguage(languageCode: string): void {
-    if (this.languageCode !== languageCode) {
-      this.languageCode = languageCode;
-      this.languageConfig = getLanguageConfig(languageCode);
-      this.executor = getIntroductionStateGraph(languageCode);
-      console.log(
-        `IntroductionStateProcessor: Language changed to ${this.languageConfig.name}`
-      );
-    }
-  }
-
-  /**
-   * Get current language code
-   */
-  getLanguageCode(): string {
-    return this.languageCode;
-  }
-
-  isComplete(): boolean {
-    return Boolean(this.state.name && this.state.level && this.state.goal);
-  }
-
-  getState(): IntroductionState {
-    return this.state;
-  }
-
-  private mergeState(newState: IntroductionState) {
-    const merged: IntroductionState = { ...this.state };
-    // Only update fields if they have a non-empty value in the new state
-    // This preserves existing values when the LLM returns empty strings
-    if (newState.name && newState.name.trim()) {
-      merged.name = newState.name.trim();
-    }
-    if (newState.level && newState.level.trim()) {
-      merged.level = newState.level as IntroductionStateLevel;
-    }
-    if (newState.goal && newState.goal.trim()) {
-      merged.goal = newState.goal.trim();
-    }
-    merged.timestamp = new Date().toISOString();
-    this.state = merged;
-    console.log(
-      'IntroductionStateProcessor - After merge, state is:',
-      this.state
-    );
-  }
-
-  async update(messages: ConversationMessage[]): Promise<IntroductionState> {
-    try {
-      const input = {
-        messages,
-        existingState: this.state,
-        target_language: this.languageConfig.name,
-      };
-
-      console.log(
-        'IntroductionStateProcessor - Current state before update:',
-        this.state
-      );
-      console.log(
-        'IntroductionStateProcessor - Messages for extraction:',
-        messages
-      );
-
-      const executionContext = {
-        executionId: uuidv4(),
-      };
-      const executionResult = await this.executor.start(
-        input,
-        executionContext
-      );
-      let finalData: GraphTypes.Content | null = null;
-      for await (const res of executionResult.outputStream) {
-        finalData = res.data;
-      }
-      const parsed = finalData as unknown as IntroductionState;
-      console.log('IntroductionStateProcessor - Extracted state:', parsed);
-      this.mergeState(parsed);
-      console.log('IntroductionStateProcessor - Merged state:', this.state);
-      return this.state;
-    } catch (error) {
-      console.error('Error updating introduction state:', error);
-      return this.state;
-    }
-  }
-
-  reset() {
-    this.state = {
-      name: '',
-      level: '',
-      goal: '',
-      timestamp: '',
-    };
-    console.log('IntroductionStateProcessor: State reset');
-  }
-}
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index b07e1ef..9f582d2 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -19,26 +19,12 @@ export const conversationTemplate = `
 - The app generates flashcards for the user during the conversation. They are ANKI formatted and can be exported by the user.
 
 # Instructions
-{% if introduction_state and (not introduction_state.name or not introduction_state.level or not introduction_state.goal) %}
-- Your first priority is to collect missing onboarding info. Ask for exactly one missing item at a time, in {{target_language}}, and keep it short and natural.
-- Missing items to collect:
-  {% if not introduction_state.name %}- Ask their name.
-  {% endif %}
-  {% if not introduction_state.level %}- Ask their {{target_language}} level (beginner, intermediate, or advanced).
-  {% endif %}
-  {% if not introduction_state.goal %}- Ask their goal for learning {{target_language}}.
-  {% endif %}
-- Do not assume or guess values. If a value was already collected, do not ask for it again.
-- If the user's latest message appears to answer one of these (e.g., they state their name, level like "beginner/intermediate/advanced" or equivalent in {{target_language}}, or share a goal), acknowledge it and immediately move to the next missing item instead of repeating the same question.
-- Use the name naturally as soon as they provide it.
-{% else %}
 - Greet the user and introduce yourself in {{target_language}}
 - Ask the user if they want a lesson or conversation on a specific topic, then proceed
 - If they don't want anything in particular, lead them in a conversation or lesson about {{example_topics}}, or any other topic which comes to mind
 - You can advise the user that if they want specific flashcards, they should just ask
 {{language_instructions}}
 - Don't always ask the user questions, you can talk about yourself as well. Be natural!
-{% endif %}
 
 # Communication Style
 - Vary your conversation starters - don't always begin with greetings or exclamations
@@ -47,7 +33,6 @@ export const conversationTemplate = `
 - Sometimes start with: direct responses, interjections, or simply dive into your response
 - Only use greetings when it's actually the start of a new conversation
 - Be conversational and natural, not overly enthusiastic with every response
-- When available, naturally use the user's name. Adjust complexity to their level (beginner, intermediate, advanced) and align topics with their goal.
 
 {% if messages and messages|length > 0 %}
 Previous conversation:
@@ -60,6 +45,8 @@ User just said: {{ current_input }}
 
 Please respond naturally and clearly in 1-2 sentences. Vary your response style and avoid starting every response with the same greeting or exclamation.`.trim();
 
+// Note: introductionStatePromptTemplate removed - no longer collecting user info upfront
+
 export const flashcardPromptTemplate = `
 
 You are a system that generates flashcards for interesting new vocabulary for a {{target_language}} learning app.
@@ -97,32 +84,3 @@ Now, return JSON with the following format:
   "example": "string",
   "mnemonic": "string"
 }`.trim();
-
-export const introductionStatePromptTemplate = `
-
-You extract onboarding information for a {{target_language}} learning app.
-
-Your job is to collect the learner's name, level, and goal ONLY if they have been explicitly provided. Do not guess or infer.
-
-Input provides the recent conversation messages and the existing known onboarding state. Preserve existing non-empty values and only fill in fields when the user clearly states them.
-
-Return a single JSON object with this exact shape:
-{
-  "name": "string",                    // The learner's name or "" if unknown
-  "level": "beginner|intermediate|advanced|", // One of these values, or "" if unknown
-  "goal": "string"                     // The learner's goal or "" if unknown
-}
-
-## Existing Known State
-{{ existingState | tojson }}
-
-## Conversation (most recent first or last order is fine)
-{% for message in messages %}
-{{ message.role }}: {{ message.content }}
-{% endfor %}
-
-## Rules
-- Do not invent values. If not explicitly provided, leave the field as an empty string.
-- Normalize level to exactly "beginner", "intermediate", or "advanced" when clearly stated; otherwise leave as "".
-- If the existing state already has a non-empty value, keep it unless the user explicitly corrects it.
-`.trim();
diff --git a/backend/server.ts b/backend/server.ts
index a07f2ce..a682a71 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -6,7 +6,6 @@
  * - ConversationGraphWrapper: The main graph that processes audio → STT → LLM → TTS
  * - ConnectionManager: Manages WebSocket connections and feeds audio to the graph
  * - FlashcardProcessor: Generates flashcards from conversations
- * - IntroductionStateProcessor: Extracts user info (name, level, goal)
  */
 
 // Load environment variables FIRST
@@ -34,7 +33,6 @@ import { ConnectionsMap } from './types/index.js';
 // Import existing components (still compatible)
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
 // import { AnkiExporter } from './helpers/anki-exporter.js';
-import { IntroductionStateProcessor } from './helpers/introduction-state-processor.js';
 import {
   getLanguageConfig,
   getLanguageOptions,
@@ -63,7 +61,6 @@ let graphWrapper: ConversationGraphWrapper | null = null;
 // Connection managers per WebSocket
 const connectionManagers = new Map<string, ConnectionManager>();
 const flashcardProcessors = new Map<string, FlashcardProcessor>();
-const introductionStateProcessors = new Map<string, IntroductionStateProcessor>();
 const connectionAttributes = new Map<
   string,
   { timezone?: string; userId?: string; languageCode?: string }
@@ -143,14 +140,12 @@ wss.on('connection', async (ws) => {
     defaultLanguageCode
   );
 
-  // Create flashcard and introduction state processors
+  // Create flashcard processor
   const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
-  const introductionStateProcessor = new IntroductionStateProcessor(defaultLanguageCode);
 
   // Store processors
   connectionManagers.set(connectionId, connectionManager);
   flashcardProcessors.set(connectionId, flashcardProcessor);
-  introductionStateProcessors.set(connectionId, introductionStateProcessor);
   connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
 
   // Set up flashcard generation callback
@@ -161,14 +156,10 @@ wss.on('connection', async (ws) => {
     }
 
     try {
-      const introState = introductionStateProcessor.getState();
       const attrs = connectionAttributes.get(connectionId) || {};
       const userAttributes: Record<string, string> = {
         timezone: attrs.timezone || '',
       };
-      userAttributes.name = introState?.name?.trim() || 'unknown';
-      userAttributes.level = (introState?.level as string) || 'unknown';
-      userAttributes.goal = introState?.goal?.trim() || 'unknown';
 
       const targetingKey = attrs.userId || connectionId;
       const userContext = {
@@ -196,22 +187,6 @@ wss.on('connection', async (ws) => {
     }
   });
 
-  // Set up introduction state extraction callback
-  connectionManager.setIntroductionStateCallback(async (messages) => {
-    try {
-      const currentState = introductionStateProcessor.getState();
-      if (introductionStateProcessor.isComplete()) {
-        return currentState;
-      }
-
-      const state = await introductionStateProcessor.update(messages);
-      return state;
-    } catch (error) {
-      console.error('[Server] Error extracting introduction state:', error);
-      return null;
-    }
-  });
-
   // Start the graph for this connection
   try {
     await connectionManager.start();
@@ -239,7 +214,6 @@ wss.on('connection', async (ws) => {
         // Reset all state
         connectionManager.reset();
         flashcardProcessors.get(connectionId)?.reset();
-        introductionStateProcessors.get(connectionId)?.reset();
         console.log(`[Server] Conversation restarted for ${connectionId}`);
       } else if (message.type === 'set_language') {
         // Handle language change
@@ -258,13 +232,11 @@ wss.on('connection', async (ws) => {
 
           // Update all processors
           flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-          introductionStateProcessors.get(connectionId)?.setLanguage(newLanguageCode);
           connectionManager.setLanguage(newLanguageCode);
 
           // Reset conversation on language change
           connectionManager.reset();
           flashcardProcessors.get(connectionId)?.reset();
-          introductionStateProcessors.get(connectionId)?.reset();
 
           // Send confirmation
           ws.send(
@@ -292,9 +264,6 @@ wss.on('connection', async (ws) => {
       } else if (message.type === 'flashcard_clicked') {
         try {
           const card = message.card || {};
-          const introState = introductionStateProcessors
-            .get(connectionId)
-            ?.getState();
           const attrs = connectionAttributes.get(connectionId) || {};
           telemetry.metric.recordCounterUInt('flashcard_clicks_total', 1, {
             connectionId,
@@ -304,9 +273,6 @@ wss.on('connection', async (ws) => {
             source: 'ui',
             timezone: attrs.timezone || '',
             languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
-            name: introState?.name?.trim() || 'unknown',
-            level: (introState?.level as string) || 'unknown',
-            goal: introState?.goal?.trim() || 'unknown',
           });
         } catch (err) {
           console.error('[Server] Error recording flashcard click:', err);
@@ -339,7 +305,6 @@ wss.on('connection', async (ws) => {
 
     // Clean up other processors
     flashcardProcessors.delete(connectionId);
-    introductionStateProcessors.delete(connectionId);
     connectionAttributes.delete(connectionId);
   });
 });
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 230273d..470925a 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -5,7 +5,6 @@
 import { WebSocket } from 'ws';
 import type { MultimodalStreamManager } from '../helpers/multimodal_stream_manager.js';
 import type { GraphOutputStream } from '@inworld/runtime/graph';
-import type { IntroductionState } from '../helpers/introduction-state-processor.js';
 
 /**
  * Chat message in conversation history
@@ -29,7 +28,6 @@ export interface State {
   userName: string;
   targetLanguage: string;
   languageCode: string;
-  introductionState: IntroductionState;
   // Output modalities (for graph routing)
   output_modalities: ('text' | 'audio')[];
 }
diff --git a/backend/types/settings.ts b/backend/types/settings.ts
index 26b0184..36573ef 100644
--- a/backend/types/settings.ts
+++ b/backend/types/settings.ts
@@ -27,13 +27,13 @@ export function getAssemblyAISettingsForEagerness(
         description:
           'Aggressive - VERY quick responses, ideal for rapid Q&A (Agent Assist, IVR)',
       };
-    case 'medium': // Balanced (default) - good for language learning
+    case 'medium': // Balanced (default) - optimized for voice-to-voice latency
       return {
-        endOfTurnConfidenceThreshold: 0.4,
-        minEndOfTurnSilenceWhenConfident: 400,
-        maxTurnSilence: 1280,
+        endOfTurnConfidenceThreshold: 0.5,
+        minEndOfTurnSilenceWhenConfident: 300,
+        maxTurnSilence: 900,
         description:
-          'Balanced - Natural conversation flow (Customer Support, Tech Support)',
+          'Balanced - Optimized for responsive voice-to-voice conversation',
       };
     case 'low': // Conservative - VERY patient
       return {
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 1677139..3804aec 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -170,6 +170,8 @@ export function AppProvider({ children }: AppProviderProps) {
 
   const pendingLLMResponseRef = useRef<string | null>(null);
   const lastPendingTranscriptionRef = useRef<string | null>(null);
+  // Track the last processed pair to prevent duplicate additions
+  const lastProcessedPairRef = useRef<{ user: string; teacher: string } | null>(null);
 
   // Refs for callbacks to avoid effect dependency issues
   const handleInterruptRef = useRef<() => void>(() => {});
@@ -231,6 +233,16 @@ export function AppProvider({ children }: AppProviderProps) {
     const pendingLLMResponse = pendingLLMResponseRef.current;
 
     if (pendingTranscription && pendingLLMResponse) {
+      // Check if we've already processed this exact pair (using ref for synchronous check)
+      const lastPair = lastProcessedPairRef.current;
+      if (lastPair && lastPair.user === pendingTranscription && lastPair.teacher === pendingLLMResponse) {
+        // Already processed this pair, just clean up
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+        pendingLLMResponseRef.current = null;
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        return;
+      }
+
       const lastUserMessage = currentState.chatHistory
         .filter((m) => m.role === 'learner')
         .pop();
@@ -243,6 +255,7 @@ export function AppProvider({ children }: AppProviderProps) {
         lastTeacherMessage?.content === pendingLLMResponse;
 
       if (isDuplicate) {
+        lastProcessedPairRef.current = { user: pendingTranscription, teacher: pendingLLMResponse };
         dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
         pendingLLMResponseRef.current = null;
         dispatch({ type: 'RESET_STREAMING_STATE' });
@@ -255,6 +268,9 @@ export function AppProvider({ children }: AppProviderProps) {
       const storage = storageRef.current;
       const wsClient = wsClientRef.current;
 
+      // Mark this pair as processed BEFORE adding (synchronous protection)
+      lastProcessedPairRef.current = { user: pendingTranscription, teacher: pendingLLMResponse };
+
       if (teacherAlreadyAdded && !userAlreadyAdded) {
         storage.addMessage('user', pendingTranscription);
         dispatch({
@@ -553,6 +569,7 @@ export function AppProvider({ children }: AppProviderProps) {
     dispatch({ type: 'RESET_CONVERSATION' });
     pendingLLMResponseRef.current = null;
     lastPendingTranscriptionRef.current = null;
+    lastProcessedPairRef.current = null;
 
     storage.saveState({ chatHistory: [] });
 
@@ -583,6 +600,7 @@ export function AppProvider({ children }: AppProviderProps) {
       dispatch({ type: 'RESET_CONVERSATION' });
       pendingLLMResponseRef.current = null;
       lastPendingTranscriptionRef.current = null;
+      lastProcessedPairRef.current = null;
 
       const flashcards = storage.getFlashcards(newLanguage);
       dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });

From 1fa67e688c784ed5bcb88810965219822f3aa0be Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:54:00 -0800
Subject: [PATCH 06/49] removed intro state graph logic

---
 backend/config/languages.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index 3695913..efc9e24 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -278,7 +278,7 @@ export function getLanguageConfig(code: string): LanguageConfig {
   const config = SUPPORTED_LANGUAGES[code];
   if (!config) {
     console.warn(
-      `Language '${code}' not found, falling back to Spanish (es)`
+      `Language '${code}' not found, falling back to Spanish (es).`
     );
     return SUPPORTED_LANGUAGES['es'];
   }

From aff49a97634425b8bf09b103232aecd029370d52 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 14:45:00 -0800
Subject: [PATCH 07/49] clean backend implementation

---
 backend/graphs/conversation-graph.ts          |   7 +-
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   | 286 ++++--------------
 backend/types/settings.ts                     |  34 ++-
 3 files changed, 88 insertions(+), 239 deletions(-)

diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 9e31917..9008288 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -93,14 +93,17 @@ export class ConversationGraphWrapper {
     const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
 
     // AssemblyAI STT with built-in VAD
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness('high');
+    // Use 'low' (conservative) settings for language learning - allows thinking pauses
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness('low');
     const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
       id: `assembly-ai-stt-ws-node${postfix}`,
       config: {
         apiKey: assemblyAIApiKey,
         connections: connections,
         sampleRate: INPUT_SAMPLE_RATE,
-        formatTurns: true,
+        // Disable format_turns - per AssemblyAI docs, this adds latency and
+        // LLMs don't need formatting. Raw text is sent as soon as it's ready.
+        formatTurns: false,
         endOfTurnConfidenceThreshold:
           turnDetectionSettings.endOfTurnConfidenceThreshold,
         minEndOfTurnSilenceWhenConfident:
diff --git a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
index 596c392..0d26e90 100644
--- a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -1,24 +1,9 @@
-/**
- * AssemblyAI Speech-to-Text WebSocket Node
- *
- * Processes continuous multimodal streams (audio and/or text) using Assembly.AI's
- * streaming Speech-to-Text service via direct WebSocket connection.
- *
- * Features:
- * - Persistent WebSocket connection per session
- * - Automatic turn detection (VAD built-in)
- * - Multi-language support
- * - Partial transcript updates
- */
-
 import { DataStreamWithMetadata } from '@inworld/runtime';
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import WebSocket from 'ws';
 import { v4 as uuidv4 } from 'uuid';
 
 import { Connection } from '../../types/index.js';
-// Settings imported but used via constructor config
-// import { getAssemblyAISettingsForEagerness } from '../../types/settings.js';
 import { audioDataToPCM16 } from '../../helpers/audio_utils.js';
 
 /**
@@ -39,7 +24,7 @@ export interface AssemblyAISTTWebSocketNodeConfig {
   minEndOfTurnSilenceWhenConfident?: number;
   /** Maximum turn silence (in milliseconds) */
   maxTurnSilence?: number;
-  /** Default language code (e.g., 'en', 'es') */
+  /** Language code (e.g., 'en', 'es') */
   language?: string;
 }
 
@@ -59,10 +44,6 @@ class AssemblyAISession {
   private lastActivityTime: number = Date.now();
   private readonly INACTIVITY_TIMEOUT_MS = 60000; // 60 seconds
 
-  // Track completed turns to prevent duplicate processing (content-based, not time-based)
-  private lastCompletedTranscript: string = '';
-  private newSpeechReceived: boolean = false;
-
   constructor(
     public readonly sessionId: string,
     private apiKey: string,
@@ -75,8 +56,7 @@ class AssemblyAISession {
    */
   public async ensureConnection(): Promise<void> {
     const now = Math.floor(Date.now() / 1000);
-    const isExpired =
-      this.sessionExpiresAt > 0 && now >= this.sessionExpiresAt;
+    const isExpired = this.sessionExpiresAt > 0 && now >= this.sessionExpiresAt;
 
     if (
       !this.ws ||
@@ -85,9 +65,7 @@ class AssemblyAISession {
       isExpired
     ) {
       if (isExpired) {
-        console.log(
-          `[AssemblyAI] Session ${this.sessionId} expired, reconnecting`
-        );
+        console.log(`[AssemblyAI] Session ${this.sessionId} expired, reconnecting`);
       }
       this.closeWebSocket();
       this.initializeWebSocket();
@@ -115,15 +93,14 @@ class AssemblyAISession {
         resolve();
       });
 
+      // Permanent message handler for session metadata
       this.ws.on('message', (data: WebSocket.Data) => {
         try {
           const message = JSON.parse(data.toString());
           if (message.type === 'Begin') {
             this.assemblySessionId = message.id || message.session_id || '';
             this.sessionExpiresAt = message.expires_at || 0;
-            console.log(
-              `[AssemblyAI] Session began: ${this.assemblySessionId}`
-            );
+            console.log(`[AssemblyAI] Session began: ${this.assemblySessionId}`);
           }
         } catch {
           // Ignore parsing errors
@@ -137,9 +114,7 @@ class AssemblyAISession {
       });
 
       this.ws.on('close', (code: number, reason: Buffer) => {
-        console.log(
-          `[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`
-        );
+        console.log(`[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`);
         this.wsReady = false;
       });
     });
@@ -157,9 +132,6 @@ class AssemblyAISession {
     }
   }
 
-  /**
-   * Send audio data directly to AssemblyAI (no buffering)
-   */
   public sendAudio(pcm16Data: Int16Array): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(Buffer.from(pcm16Data.buffer));
@@ -179,9 +151,7 @@ class AssemblyAISession {
 
   private closeDueToInactivity(): void {
     const inactiveFor = Date.now() - this.lastActivityTime;
-    console.log(
-      `[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`
-    );
+    console.log(`[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`);
     this.shouldStopProcessing = true;
     this.close();
     this.onCleanup(this.sessionId);
@@ -218,70 +188,18 @@ class AssemblyAISession {
 
     this.closeWebSocket();
   }
-
-  /**
-   * Mark that new speech was received (partial transcript)
-   */
-  public markNewSpeechReceived(): void {
-    this.newSpeechReceived = true;
-  }
-
-  /**
-   * Check if a turn should be accepted or rejected as duplicate
-   * Returns true if the turn is valid and should be processed
-   *
-   * Note: We use content-based deduplication instead of time-based debouncing
-   * to avoid adding latency while still preventing duplicate processing.
-   */
-  public shouldAcceptTurn(transcript: string): boolean {
-    // If new speech was received since last turn, always accept
-    if (this.newSpeechReceived) {
-      return true;
-    }
-
-    // No new speech - check for duplicate content
-    if (!this.lastCompletedTranscript) {
-      return true; // No previous turn to compare against
-    }
-
-    // Normalize transcripts for comparison (lowercase, remove punctuation, trim)
-    const normalizeText = (text: string) =>
-      text.toLowerCase().replace(/[.,!?;:'"]/g, '').replace(/\s+/g, ' ').trim();
-
-    const normalizedNew = normalizeText(transcript);
-    const normalizedLast = normalizeText(this.lastCompletedTranscript);
-
-    // Check if transcripts are similar (allowing for minor formatting differences)
-    const isSimilar = normalizedNew === normalizedLast ||
-                     normalizedNew.includes(normalizedLast) ||
-                     normalizedLast.includes(normalizedNew);
-
-    if (isSimilar) {
-      console.log(`[AssemblyAI] Rejecting turn - duplicate content without new speech`);
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Mark that a turn was completed - store for deduplication
-   */
-  public markTurnCompleted(transcript: string): void {
-    this.lastCompletedTranscript = transcript;
-    this.newSpeechReceived = false; // Reset for next turn
-  }
-
-  /**
-   * Reset turn tracking state (call when starting fresh interaction)
-   */
-  public resetTurnTracking(): void {
-    this.newSpeechReceived = false;
-  }
 }
 
 /**
- * AssemblyAI STT WebSocket Node for the Inworld runtime graph
+ * AssemblyAISTTWebSocketNode processes continuous multimodal streams using Assembly.AI's
+ * streaming Speech-to-Text service via direct WebSocket connection.
+ *
+ * This node:
+ * - Receives MultimodalContent stream (audio and/or text)
+ * - For audio: extracts audio and feeds to Assembly.AI streaming transcriber
+ * - For text: bypasses STT and returns text directly
+ * - Detects turn endings using Assembly.AI's neural turn detection
+ * - Returns DataStreamWithMetadata with transcribed text when a turn completes
  */
 export class AssemblyAISTTWebSocketNode extends CustomNode {
   private apiKey: string;
@@ -291,12 +209,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
   private endOfTurnConfidenceThreshold: number;
   private minEndOfTurnSilenceWhenConfident: number;
   private maxTurnSilence: number;
-  private defaultLanguage: string;
+  private language: string;
   private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
 
   private sessions: Map<string, AssemblyAISession> = new Map();
-  // Reduced from 2000ms for faster response when audio ends before turn detection
-  private readonly TURN_COMPLETION_TIMEOUT_MS = 1200;
+  private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
   private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
 
   constructor(props: { id?: string; config: AssemblyAISTTWebSocketNodeConfig }) {
@@ -309,18 +226,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       throw new Error('AssemblyAISTTWebSocketNode requires a connections object.');
     }
 
-    // Optimized defaults for lower latency voice-to-voice interaction:
-    // - Higher confidence threshold (0.5) detects turns faster with more certainty
-    // - Lower silence thresholds (300ms/900ms) reduce wait time after speech ends
     super({
       id: nodeProps.id || 'assembly-ai-stt-ws-node',
       executionConfig: {
         sampleRate: config.sampleRate || 16000,
-        formatTurns: config.formatTurns !== false,
-        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold || 0.5,
-        minEndOfTurnSilenceWhenConfident:
-          config.minEndOfTurnSilenceWhenConfident || 300,
-        maxTurnSilence: config.maxTurnSilence || 900,
+        formatTurns: config.formatTurns ?? false,
+        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold ?? 0.7,
+        minEndOfTurnSilenceWhenConfident: config.minEndOfTurnSilenceWhenConfident ?? 800,
+        maxTurnSilence: config.maxTurnSilence ?? 3600,
         language: config.language || 'es',
       },
     });
@@ -328,65 +241,50 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.apiKey = config.apiKey;
     this.connections = config.connections;
     this.sampleRate = config.sampleRate || 16000;
-    this.formatTurns = config.formatTurns !== false;
-    this.endOfTurnConfidenceThreshold =
-      config.endOfTurnConfidenceThreshold || 0.5;
-    this.minEndOfTurnSilenceWhenConfident =
-      config.minEndOfTurnSilenceWhenConfident || 300;
-    this.maxTurnSilence = config.maxTurnSilence || 900;
-    this.defaultLanguage = config.language || 'es';
-
-    const defaultModel = this.defaultLanguage === 'en'
-      ? 'universal-streaming-english'
-      : 'universal-streaming-multilingual';
+    this.formatTurns = config.formatTurns ?? false;
+    this.endOfTurnConfidenceThreshold = config.endOfTurnConfidenceThreshold ?? 0.7;
+    this.minEndOfTurnSilenceWhenConfident = config.minEndOfTurnSilenceWhenConfident ?? 800;
+    this.maxTurnSilence = config.maxTurnSilence ?? 3600;
+    this.language = config.language || 'es';
+
     console.log(
-      `[AssemblyAI] Configured with [model:${defaultModel}] [threshold:${this.endOfTurnConfidenceThreshold}] [silence:${this.minEndOfTurnSilenceWhenConfident}ms] [lang:${this.defaultLanguage}]`
+      `[AssemblyAI] Configured [threshold:${this.endOfTurnConfidenceThreshold}] [minSilence:${this.minEndOfTurnSilenceWhenConfident}ms] [maxSilence:${this.maxTurnSilence}ms] [lang:${this.language}]`
     );
   }
 
   /**
    * Build WebSocket URL with query parameters
-   * Dynamically uses connection.state.languageCode if available
    */
   private buildWebSocketUrl(sessionId?: string): string {
-    let endOfTurnThreshold = this.endOfTurnConfidenceThreshold;
-    let minSilenceWhenConfident = this.minEndOfTurnSilenceWhenConfident;
-    let maxSilence = this.maxTurnSilence;
-    let language = this.defaultLanguage;
+    let language = this.language;
 
     if (sessionId) {
       const connection = this.connections[sessionId];
-      // Get language from connection state (supports dynamic language switching)
       if (connection?.state?.languageCode) {
-        // Extract base language code (e.g., 'es' from 'es-MX')
         language = connection.state.languageCode.split('-')[0];
       }
     }
 
     // Determine speech model based on language
-    // AssemblyAI's streaming v3 API:
-    // - 'universal-streaming-english' for English only (default)
-    // - 'universal-streaming-multilingual' for other languages (Spanish, Japanese, etc.)
     const isEnglish = language === 'en';
     const speechModel = isEnglish
       ? 'universal-streaming-english'
       : 'universal-streaming-multilingual';
 
-
     const params = new URLSearchParams({
       sample_rate: this.sampleRate.toString(),
-      encoding: 'pcm_s16le', // Signed 16-bit little-endian PCM
+      encoding: 'pcm_s16le',
       format_turns: this.formatTurns.toString(),
-      end_of_turn_confidence_threshold: endOfTurnThreshold.toString(),
-      min_end_of_turn_silence_when_confident: minSilenceWhenConfident.toString(),
-      max_turn_silence: maxSilence.toString(),
+      end_of_turn_confidence_threshold: this.endOfTurnConfidenceThreshold.toString(),
+      min_end_of_turn_silence_when_confident: this.minEndOfTurnSilenceWhenConfident.toString(),
+      max_turn_silence: this.maxTurnSilence.toString(),
       speech_model: speechModel,
-      language_detection: 'true'.toString()
+      language_detection: 'true',
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
     console.log(
-      `[AssemblyAI] Connecting with [model:${speechModel}] [lang:${language}] [threshold:${endOfTurnThreshold}]`
+      `[AssemblyAI] Connecting [model:${speechModel}] [lang:${language}] [threshold:${this.endOfTurnConfidenceThreshold}] [maxSilence:${this.maxTurnSilence}ms]`
     );
 
     return url;
@@ -417,14 +315,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       throw Error(`Failed to read connection for sessionId: ${sessionId}`);
     }
 
-    // Get or parse iteration from metadata
+    // Get iteration from metadata or parse from interactionId
     const metadata = input?.getMetadata?.() || {};
     let previousIteration = (metadata.iteration as number) || 0;
 
-    if (
-      !connection.state.interactionId ||
-      connection.state.interactionId === ''
-    ) {
+    if (!connection.state.interactionId || connection.state.interactionId === '') {
       connection.state.interactionId = uuidv4();
     }
 
@@ -440,10 +335,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
 
     const iteration = previousIteration + 1;
-    const baseId =
-      delimiterIndex !== -1
-        ? currentId.substring(0, delimiterIndex)
-        : currentId;
+    const baseId = delimiterIndex !== -1 ? currentId.substring(0, delimiterIndex) : currentId;
     const nextInteractionId = `${baseId}#${iteration}`;
 
     console.log(`[AssemblyAI] Starting transcription [iteration:${iteration}]`);
@@ -486,7 +378,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       return value;
     });
 
-    // AssemblyAI message handler
+    // AssemblyAI message handler for this process() call
     const messageHandler = (data: WebSocket.Data) => {
       try {
         const message = JSON.parse(data.toString());
@@ -494,7 +386,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
         if (msgType === 'Turn') {
           if (session?.shouldStopProcessing) {
-            console.log(`[AssemblyAI] Ignoring Turn - processing stopped [iteration:${iteration}]`);
             return;
           }
 
@@ -505,14 +396,9 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
           if (!transcript) return;
 
           if (!isFinal) {
-            // Partial transcript - mark that we're receiving new speech
+            // Partial transcript
             const textToSend = utterance || transcript;
             if (textToSend) {
-              console.log(`[AssemblyAI] Partial [iteration:${iteration}]: "${textToSend.substring(0, 30)}..."`);
-
-              // Mark new speech received BEFORE sending partial
-              session?.markNewSpeechReceived();
-
               this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
 
               if (connection?.onSpeechDetected && !speechDetected) {
@@ -524,29 +410,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             return;
           }
 
-          // Final transcript - check for duplicates
-          console.log(
-            `[AssemblyAI] Turn candidate [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
-          );
-
-          // Check if we should accept this turn (not a duplicate)
-          if (session && !session.shouldAcceptTurn(transcript)) {
-            console.log(`[AssemblyAI] Turn rejected as duplicate [iteration:${iteration}]`);
-            return;
-          }
-
-          // Accept the turn
-          console.log(
-            `[AssemblyAI] Turn ACCEPTED [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
-          );
+          // Final transcript
+          console.log(`[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
 
           transcriptText = transcript;
           turnDetected = true;
-          if (session) {
-            session.shouldStopProcessing = true;
-            session.markTurnCompleted(transcript);
-          }
+          if (session) session.shouldStopProcessing = true;
           turnResolve(transcript);
+
         } else if (msgType === 'Termination') {
           console.log(`[AssemblyAI] Session terminated [iteration:${iteration}]`);
         }
@@ -563,25 +434,23 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       const audioProcessingPromise = (async () => {
         let maxDurationTimeout: NodeJS.Timeout | null = null;
         try {
+          // Safety timer: prevent infinite loops
           maxDurationTimeout = setTimeout(() => {
             maxDurationReached = true;
           }, this.MAX_TRANSCRIPTION_DURATION_MS);
 
           while (true) {
             if (session?.shouldStopProcessing) break;
+
             if (maxDurationReached && !transcriptText) {
-              console.warn(
-                `[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`
-              );
+              console.warn(`[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`);
               break;
             }
 
             const result = await multimodalStream.next();
 
             if (result.done) {
-              console.log(
-                `[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`
-              );
+              console.log(`[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`);
               isStreamExhausted = true;
               break;
             }
@@ -592,9 +461,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
             // Handle text input
             if (content.text !== undefined && content.text !== null) {
-              console.log(
-                `[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`
-              );
+              console.log(`[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`);
               isTextInput = true;
               textContent = content.text;
               transcriptText = content.text;
@@ -604,20 +471,15 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
               break;
             }
 
-            // Extract audio from MultimodalContent
-            if (content.audio === undefined || content.audio === null) {
-              continue;
-            }
+            // Extract audio
+            if (content.audio === undefined || content.audio === null) continue;
 
             const audioData = content.audio.data;
-            if (!audioData || audioData.length === 0) {
-              continue;
-            }
+            if (!audioData || audioData.length === 0) continue;
 
             audioChunkCount++;
             totalAudioSamples += audioData.length;
 
-            // Convert directly to PCM16 without intermediate Float32Array allocation
             const pcm16Data = audioDataToPCM16(audioData);
             session?.sendAudio(pcm16Data);
           }
@@ -638,20 +500,12 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         audioProcessingPromise.then(() => ({ winner: 'audio' as const })),
       ]);
 
-      if (
-        raceResult.winner === 'audio' &&
-        !turnCompleted &&
-        !maxDurationReached
-      ) {
-        console.log(
-          `[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`
-        );
+      if (raceResult.winner === 'audio' && !turnCompleted && !maxDurationReached) {
+        console.log(`[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`);
 
-        // Send silence to keep connection alive
+        // Send silence to keep connection alive - AssemblyAI needs continuous audio
         const silenceIntervalMs = 100;
-        const silenceSamples = Math.floor(
-          (silenceIntervalMs / 1000) * this.sampleRate
-        );
+        const silenceSamples = Math.floor((silenceIntervalMs / 1000) * this.sampleRate);
         const silenceFrame = new Int16Array(silenceSamples);
         const silenceTimer = setInterval(() => {
           if (session && !session.shouldStopProcessing) {
@@ -660,10 +514,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         }, silenceIntervalMs);
 
         const timeoutPromise = new Promise<{ winner: 'timeout' }>((resolve) =>
-          setTimeout(
-            () => resolve({ winner: 'timeout' }),
-            this.TURN_COMPLETION_TIMEOUT_MS
-          )
+          setTimeout(() => resolve({ winner: 'timeout' }), this.TURN_COMPLETION_TIMEOUT_MS)
         );
 
         const waitResult = await Promise.race([
@@ -681,15 +532,12 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
       await audioProcessingPromise.catch(() => {});
 
-      console.log(
-        `[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`
-      );
+      console.log(`[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`);
 
       if (turnDetected) {
         connection.state.interactionId = '';
       }
 
-      // Tag the stream for runtime
       const taggedStream = Object.assign(multimodalStream, {
         type: 'MultimodalContent',
         abort: () => {},
@@ -744,15 +592,9 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
   }
 
-  private sendPartialTranscript(
-    sessionId: string,
-    interactionId: string,
-    text: string
-  ): void {
+  private sendPartialTranscript(sessionId: string, interactionId: string, text: string): void {
     const connection = this.connections[sessionId];
-    if (!connection?.onPartialTranscript) {
-      return;
-    }
+    if (!connection?.onPartialTranscript) return;
 
     try {
       connection.onPartialTranscript(text, interactionId);
@@ -761,9 +603,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
   }
 
-  /**
-   * Close a specific session by sessionId
-   */
   async closeSession(sessionId: string): Promise<void> {
     const session = this.sessions.get(sessionId);
     if (session) {
@@ -773,9 +612,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
   }
 
-  /**
-   * Clean up all resources
-   */
   async destroy(): Promise<void> {
     console.log(`[AssemblyAI] Destroying node: closing ${this.sessions.size} sessions`);
 
diff --git a/backend/types/settings.ts b/backend/types/settings.ts
index 36573ef..4f8e7b6 100644
--- a/backend/types/settings.ts
+++ b/backend/types/settings.ts
@@ -1,6 +1,8 @@
 /**
  * Maps eagerness levels to AssemblyAI turn detection settings
  * Based on AssemblyAI's recommended configurations for different use cases
+ *
+ * @see https://www.assemblyai.com/docs/speech-to-text/universal-streaming/turn-detection
  */
 
 export interface AssemblyAITurnDetectionSettings {
@@ -12,36 +14,44 @@ export interface AssemblyAITurnDetectionSettings {
 
 /**
  * Get AssemblyAI turn detection settings for a given eagerness level
+ *
+ * AssemblyAI's turn detection model uses:
+ * - Semantic detection: Neural network predicts when speech naturally ends
+ * - Acoustic detection: Traditional silence-based detection as backup (VAD)
+ *
  * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
  * @returns AssemblyAI turn detection settings including threshold values and description
  */
 export function getAssemblyAISettingsForEagerness(
-  eagerness: 'low' | 'medium' | 'high' = 'medium'
+  eagerness: 'low' | 'medium' | 'high' = 'low'
 ): AssemblyAITurnDetectionSettings {
   switch (eagerness) {
-    case 'high': // Aggressive - VERY responsive
+    case 'high': // Aggressive - per AssemblyAI docs
+      // Use cases: Agent Assist, IVR replacements, Retail/E-commerce, Telecom
       return {
         endOfTurnConfidenceThreshold: 0.4,
         minEndOfTurnSilenceWhenConfident: 160,
-        maxTurnSilence: 320,
+        maxTurnSilence: 400,
         description:
-          'Aggressive - VERY quick responses, ideal for rapid Q&A (Agent Assist, IVR)',
+          'Aggressive - Quick responses for rapid back-and-forth (IVR, order confirmations)',
       };
-    case 'medium': // Balanced (default) - optimized for voice-to-voice latency
+    case 'medium': // Balanced - per AssemblyAI docs
+      // Use cases: Customer Support, Tech Support, Financial Services, Travel
       return {
-        endOfTurnConfidenceThreshold: 0.5,
-        minEndOfTurnSilenceWhenConfident: 300,
-        maxTurnSilence: 900,
+        endOfTurnConfidenceThreshold: 0.4,
+        minEndOfTurnSilenceWhenConfident: 400,
+        maxTurnSilence: 1280,
         description:
-          'Balanced - Optimized for responsive voice-to-voice conversation',
+          'Balanced - Natural middle ground for most conversational turns',
       };
-    case 'low': // Conservative - VERY patient
+    case 'low': // Conservative - per AssemblyAI docs
+      // Use cases: Healthcare, Mental Health, Sales, Legal, LANGUAGE LEARNING
       return {
         endOfTurnConfidenceThreshold: 0.7,
         minEndOfTurnSilenceWhenConfident: 800,
-        maxTurnSilence: 3000,
+        maxTurnSilence: 3600,
         description:
-          'Conservative - VERY patient, allows long thinking pauses (Complex inquiries)',
+          'Conservative - Patient, allows thinking pauses (Language Learning, Healthcare)',
       };
   }
 }

From 2d46b7ceea70c64e3a54add663a59c6ee6837f03 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 20:35:30 -0800
Subject: [PATCH 08/49] code cleanup

---
 backend/graphs/conversation-graph.ts | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 9008288..4c05a6b 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -93,16 +93,13 @@ export class ConversationGraphWrapper {
     const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
 
     // AssemblyAI STT with built-in VAD
-    // Use 'low' (conservative) settings for language learning - allows thinking pauses
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness('low');
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness('high');
     const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
       id: `assembly-ai-stt-ws-node${postfix}`,
       config: {
         apiKey: assemblyAIApiKey,
         connections: connections,
         sampleRate: INPUT_SAMPLE_RATE,
-        // Disable format_turns - per AssemblyAI docs, this adds latency and
-        // LLMs don't need formatting. Raw text is sent as soon as it's ready.
         formatTurns: false,
         endOfTurnConfidenceThreshold:
           turnDetectionSettings.endOfTurnConfidenceThreshold,
@@ -139,7 +136,7 @@ export class ConversationGraphWrapper {
     const llmNode = new RemoteLLMChatNode({
       id: `llm-node${postfix}`,
       provider: 'openai',
-      modelName: 'gpt-4o-mini',
+      modelName: 'gpt-4.1-nano',
       stream: true,
       textGenerationConfig: {
         maxNewTokens: 250,

From 0a556638c278b828a364144b44cada14fb7b0817 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 20:59:57 -0800
Subject: [PATCH 09/49] code cleanup and added text input

---
 backend/graphs/conversation-graph.ts          |  19 +--
 .../graphs/nodes/assembly_ai_stt_ws_node.ts   |  41 +-----
 backend/helpers/connection-manager.ts         |  13 ++
 backend/server.ts                             |  44 ++++++-
 frontend/src/components/ChatSection.tsx       |  71 ++++++++--
 frontend/src/components/StreamingMessage.tsx  |  19 +--
 frontend/src/context/AppContext.tsx           | 121 ++++++++++++++----
 frontend/src/hooks/useTypewriter.ts           |  63 ---------
 frontend/src/styles/main.css                  |  85 +++++++++---
 9 files changed, 279 insertions(+), 197 deletions(-)
 delete mode 100644 frontend/src/hooks/useTypewriter.ts

diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 4c05a6b..ec060c3 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -92,8 +92,8 @@ export class ConversationGraphWrapper {
     // Start node (audio input proxy)
     const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
 
-    // AssemblyAI STT with built-in VAD
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness('high');
+    // AssemblyAI STT with built-in VAD (always uses multilingual model)
+    const turnDetectionSettings = getAssemblyAISettingsForEagerness('medium');
     const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
       id: `assembly-ai-stt-ws-node${postfix}`,
       config: {
@@ -106,7 +106,6 @@ export class ConversationGraphWrapper {
         minEndOfTurnSilenceWhenConfident:
           turnDetectionSettings.minEndOfTurnSilenceWhenConfident,
         maxTurnSilence: turnDetectionSettings.maxTurnSilence,
-        language: defaultLanguageCode.split('-')[0], // 'es' from 'es-MX'
       },
     });
 
@@ -289,17 +288,3 @@ export class ConversationGraphWrapper {
     });
   }
 }
-
-/**
- * Legacy export for backwards compatibility during migration
- */
-export function getConversationGraph(
-  _config: { apiKey: string },
-  _languageCode: string = DEFAULT_LANGUAGE_CODE
-): Graph {
-  console.warn(
-    '[ConversationGraph] getConversationGraph is deprecated. Use ConversationGraphWrapper.create() instead.'
-  );
-  // This won't work properly without connections, but maintains API compatibility
-  return null as unknown as Graph;
-}
diff --git a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
index 0d26e90..8db92cc 100644
--- a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
@@ -24,8 +24,6 @@ export interface AssemblyAISTTWebSocketNodeConfig {
   minEndOfTurnSilenceWhenConfident?: number;
   /** Maximum turn silence (in milliseconds) */
   maxTurnSilence?: number;
-  /** Language code (e.g., 'en', 'es') */
-  language?: string;
 }
 
 /**
@@ -209,7 +207,6 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
   private endOfTurnConfidenceThreshold: number;
   private minEndOfTurnSilenceWhenConfident: number;
   private maxTurnSilence: number;
-  private language: string;
   private wsEndpointBaseUrl: string = 'wss://streaming.assemblyai.com/v3/ws';
 
   private sessions: Map<string, AssemblyAISession> = new Map();
@@ -226,17 +223,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       throw new Error('AssemblyAISTTWebSocketNode requires a connections object.');
     }
 
-    super({
-      id: nodeProps.id || 'assembly-ai-stt-ws-node',
-      executionConfig: {
-        sampleRate: config.sampleRate || 16000,
-        formatTurns: config.formatTurns ?? false,
-        endOfTurnConfidenceThreshold: config.endOfTurnConfidenceThreshold ?? 0.7,
-        minEndOfTurnSilenceWhenConfident: config.minEndOfTurnSilenceWhenConfident ?? 800,
-        maxTurnSilence: config.maxTurnSilence ?? 3600,
-        language: config.language || 'es',
-      },
-    });
+    super({ id: nodeProps.id || 'assembly-ai-stt-ws-node' });
 
     this.apiKey = config.apiKey;
     this.connections = config.connections;
@@ -245,32 +232,16 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.endOfTurnConfidenceThreshold = config.endOfTurnConfidenceThreshold ?? 0.7;
     this.minEndOfTurnSilenceWhenConfident = config.minEndOfTurnSilenceWhenConfident ?? 800;
     this.maxTurnSilence = config.maxTurnSilence ?? 3600;
-    this.language = config.language || 'es';
 
     console.log(
-      `[AssemblyAI] Configured [threshold:${this.endOfTurnConfidenceThreshold}] [minSilence:${this.minEndOfTurnSilenceWhenConfident}ms] [maxSilence:${this.maxTurnSilence}ms] [lang:${this.language}]`
+      `[AssemblyAI] Configured [threshold:${this.endOfTurnConfidenceThreshold}] [minSilence:${this.minEndOfTurnSilenceWhenConfident}ms] [maxSilence:${this.maxTurnSilence}ms]`
     );
   }
 
   /**
    * Build WebSocket URL with query parameters
    */
-  private buildWebSocketUrl(sessionId?: string): string {
-    let language = this.language;
-
-    if (sessionId) {
-      const connection = this.connections[sessionId];
-      if (connection?.state?.languageCode) {
-        language = connection.state.languageCode.split('-')[0];
-      }
-    }
-
-    // Determine speech model based on language
-    const isEnglish = language === 'en';
-    const speechModel = isEnglish
-      ? 'universal-streaming-english'
-      : 'universal-streaming-multilingual';
-
+  private buildWebSocketUrl(): string {
     const params = new URLSearchParams({
       sample_rate: this.sampleRate.toString(),
       encoding: 'pcm_s16le',
@@ -278,13 +249,13 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       end_of_turn_confidence_threshold: this.endOfTurnConfidenceThreshold.toString(),
       min_end_of_turn_silence_when_confident: this.minEndOfTurnSilenceWhenConfident.toString(),
       max_turn_silence: this.maxTurnSilence.toString(),
-      speech_model: speechModel,
+      speech_model: 'universal-streaming-multilingual',
       language_detection: 'true',
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
     console.log(
-      `[AssemblyAI] Connecting [model:${speechModel}] [lang:${language}] [threshold:${this.endOfTurnConfidenceThreshold}] [maxSilence:${this.maxTurnSilence}ms]`
+      `[AssemblyAI] Connecting [model:universal-streaming-multilingual] [threshold:${this.endOfTurnConfidenceThreshold}] [maxSilence:${this.maxTurnSilence}ms]`
     );
 
     return url;
@@ -359,7 +330,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       session = new AssemblyAISession(
         sessionId,
         this.apiKey,
-        this.buildWebSocketUrl(sessionId),
+        this.buildWebSocketUrl(),
         (id) => this.sessions.delete(id)
       );
       this.sessions.set(sessionId, session);
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index d060a3a..e69fd07 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -493,6 +493,19 @@ export class ConnectionManager {
     console.log('[ConnectionManager] Conversation reset');
   }
 
+  /**
+   * Send a text message (bypasses audio/STT, goes directly to LLM)
+   */
+  sendTextMessage(text: string): void {
+    if (this.isDestroyed) return;
+
+    const trimmedText = text.trim();
+    if (!trimmedText) return;
+
+    console.log(`[ConnectionManager] Sending text message: "${trimmedText.substring(0, 50)}..."`);
+    this.multimodalStreamManager.pushText(trimmedText);
+  }
+
   /**
    * Clean up resources
    */
diff --git a/backend/server.ts b/backend/server.ts
index a682a71..21726fa 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -32,7 +32,7 @@ import { ConnectionsMap } from './types/index.js';
 
 // Import existing components (still compatible)
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
-// import { AnkiExporter } from './helpers/anki-exporter.js';
+import { AnkiExporter } from './helpers/anki-exporter.js';
 import {
   getLanguageConfig,
   getLanguageOptions,
@@ -277,6 +277,9 @@ wss.on('connection', async (ws) => {
         } catch (err) {
           console.error('[Server] Error recording flashcard click:', err);
         }
+      } else if (message.type === 'text_message' && message.text) {
+        // Handle text input (bypasses audio/STT)
+        connectionManager.sendTextMessage(message.text);
       } else {
         console.log('[Server] Received message type:', message.type);
       }
@@ -313,10 +316,41 @@ wss.on('connection', async (ws) => {
 // API Endpoints
 // ============================================================
 
-// ANKI export endpoint - temporarily disabled
-// app.post('/api/export-anki', async (req, res) => {
-//   ...
-// });
+// ANKI export endpoint
+app.post('/api/export-anki', async (req, res) => {
+  try {
+    const { flashcards, deckName, languageCode } = req.body;
+
+    if (!flashcards || !Array.isArray(flashcards) || flashcards.length === 0) {
+      res.status(400).json({ error: 'No flashcards provided' });
+      return;
+    }
+
+    const exporter = new AnkiExporter();
+    const validCount = exporter.countValidFlashcards(flashcards);
+
+    if (validCount === 0) {
+      res.status(400).json({ error: 'No valid flashcards to export' });
+      return;
+    }
+
+    const defaultDeckName = `Aprendemo ${languageCode || 'Language'} Cards`;
+    const apkgBuffer = await exporter.exportFlashcards(
+      flashcards,
+      deckName || defaultDeckName
+    );
+
+    res.setHeader('Content-Type', 'application/octet-stream');
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename="${(deckName || defaultDeckName).replace(/[^a-zA-Z0-9]/g, '_')}.apkg"`
+    );
+    res.send(apkgBuffer);
+  } catch (error) {
+    console.error('[Server] Error exporting Anki deck:', error);
+    res.status(500).json({ error: 'Failed to export Anki deck' });
+  }
+});
 
 // Languages endpoint
 app.get('/api/languages', (_req, res) => {
diff --git a/frontend/src/components/ChatSection.tsx b/frontend/src/components/ChatSection.tsx
index 0143564..6f7afb2 100644
--- a/frontend/src/components/ChatSection.tsx
+++ b/frontend/src/components/ChatSection.tsx
@@ -1,10 +1,11 @@
-import { useEffect, useRef, useCallback } from 'react';
+import { useEffect, useRef, useCallback, useState, type FormEvent, type KeyboardEvent } from 'react';
 import { useApp } from '../context/AppContext';
 import { Message } from './Message';
 import { StreamingMessage } from './StreamingMessage';
 
 export function ChatSection() {
-  const { state, toggleRecording, restartConversation } = useApp();
+  const { state, toggleRecording, restartConversation, sendTextMessage } = useApp();
+  const [textInput, setTextInput] = useState('');
   const {
     chatHistory,
     currentTranscript,
@@ -53,14 +54,29 @@ export function ChatSection() {
     scrollToBottomInstant();
   }, [currentTranscript, pendingTranscription, streamingLLMResponse, scrollToBottomInstant]);
 
-  // Callback for child components to trigger scroll during typewriter animation
-  const handleContentUpdate = useCallback(() => {
-    scrollToBottomInstant();
-  }, [scrollToBottomInstant]);
+  const handleTextSubmit = useCallback(
+    (e: FormEvent) => {
+      e.preventDefault();
+      if (textInput.trim()) {
+        sendTextMessage(textInput);
+        setTextInput('');
+      }
+    },
+    [textInput, sendTextMessage]
+  );
 
-  const handleLLMTypewriterComplete = useCallback(() => {
-    // Completion is handled in AppContext
-  }, []);
+  const handleKeyDown = useCallback(
+    (e: KeyboardEvent<HTMLInputElement>) => {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        if (textInput.trim()) {
+          sendTextMessage(textInput);
+          setTextInput('');
+        }
+      }
+    },
+    [textInput, sendTextMessage]
+  );
 
   const isConnected = connectionStatus === 'connected';
 
@@ -141,16 +157,43 @@ export function ChatSection() {
 
           {/* Streaming LLM response */}
           {streamingLLMResponse && (
-            <StreamingMessage
-              text={streamingLLMResponse}
-              onComplete={handleLLMTypewriterComplete}
-              onContentUpdate={handleContentUpdate}
-            />
+            <StreamingMessage text={streamingLLMResponse} />
           )}
         </div>
         <div className="current-transcript" id="currentTranscript">
           {currentTranscript}
         </div>
+        <form className="text-input-form" onSubmit={handleTextSubmit}>
+          <input
+            type="text"
+            className="text-input"
+            placeholder="Type a message..."
+            value={textInput}
+            onChange={(e) => setTextInput(e.target.value)}
+            onKeyDown={handleKeyDown}
+            disabled={!isConnected}
+          />
+          <button
+            type="submit"
+            className="send-button"
+            disabled={!isConnected || !textInput.trim()}
+            title="Send message"
+          >
+            <svg
+              width="20"
+              height="20"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              strokeWidth="2"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            >
+              <line x1="22" y1="2" x2="11" y2="13" />
+              <polygon points="22 2 15 22 11 13 2 9 22 2" />
+            </svg>
+          </button>
+        </form>
       </div>
     </section>
   );
diff --git a/frontend/src/components/StreamingMessage.tsx b/frontend/src/components/StreamingMessage.tsx
index 7712d9a..b2615bc 100644
--- a/frontend/src/components/StreamingMessage.tsx
+++ b/frontend/src/components/StreamingMessage.tsx
@@ -1,20 +1,11 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
-import { useTypewriter } from '../hooks/useTypewriter';
 import { TranslationTooltip } from './TranslationTooltip';
 
 interface StreamingMessageProps {
   text: string;
-  onComplete?: () => void;
-  onContentUpdate?: () => void;
 }
 
-export function StreamingMessage({ text, onComplete, onContentUpdate }: StreamingMessageProps) {
-  const { displayedText, isTyping } = useTypewriter(text, {
-    speed: 25,
-    onComplete,
-    onContentUpdate,
-  });
-
+export function StreamingMessage({ text }: StreamingMessageProps) {
   const [showTooltip, setShowTooltip] = useState(false);
   const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });
   const messageRef = useRef<HTMLDivElement>(null);
@@ -68,9 +59,6 @@ export function StreamingMessage({ text, onComplete, onContentUpdate }: Streamin
     };
   }, []);
 
-  // Get text for translation (remove cursor)
-  const textForTranslation = displayedText.replace('▊', '').trim();
-
   return (
     <>
       <div
@@ -79,11 +67,10 @@ export function StreamingMessage({ text, onComplete, onContentUpdate }: Streamin
         onMouseEnter={handleMouseEnter}
         onMouseLeave={handleMouseLeave}
       >
-        {displayedText}
-        {isTyping && <span className="streaming-cursor">▊</span>}
+        {text}
       </div>
       <TranslationTooltip
-        text={textForTranslation}
+        text={text}
         visible={showTooltip}
         position={tooltipPosition}
         onMouseEnter={handleTooltipMouseEnter}
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 3804aec..5f89672 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -139,6 +139,7 @@ interface AppContextType {
   restartConversation: () => void;
   changeLanguage: (newLanguage: string) => void;
   handleInterrupt: () => void;
+  sendTextMessage: (text: string) => void;
 }
 
 const AppContext = createContext<AppContextType | null>(null);
@@ -217,8 +218,6 @@ export function AppProvider({ children }: AppProviderProps) {
           type: 'SET_AVAILABLE_LANGUAGES',
           payload: [
             { code: 'es', name: 'Spanish', nativeName: 'Español', flag: '🇲🇽' },
-            { code: 'ja', name: 'Japanese', nativeName: '日本語', flag: '🇯🇵' },
-            { code: 'fr', name: 'French', nativeName: 'Français', flag: '🇫🇷' },
           ],
         });
       }
@@ -232,6 +231,41 @@ export function AppProvider({ children }: AppProviderProps) {
     const pendingTranscription = currentState.pendingTranscription;
     const pendingLLMResponse = pendingLLMResponseRef.current;
 
+    const storage = storageRef.current;
+    const wsClient = wsClientRef.current;
+
+    const lastUserMessage = currentState.chatHistory
+      .filter((m) => m.role === 'learner')
+      .pop();
+    const lastTeacherMessage = currentState.chatHistory
+      .filter((m) => m.role === 'teacher')
+      .pop();
+
+    // Case 1: We have a pending LLM response but user message was already added (text input case)
+    if (pendingLLMResponse && !pendingTranscription) {
+      // Check if teacher response is already in history
+      if (lastTeacherMessage?.content === pendingLLMResponse) {
+        pendingLLMResponseRef.current = null;
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        return;
+      }
+
+      // Add only the teacher response
+      storage.addMessage('assistant', pendingLLMResponse);
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'teacher', content: pendingLLMResponse },
+      });
+
+      const conversationHistory = storage.getConversationHistory();
+      wsClient.send({ type: 'conversation_update', data: conversationHistory });
+
+      pendingLLMResponseRef.current = null;
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+      return;
+    }
+
+    // Case 2: We have both pending transcription and LLM response (audio input case)
     if (pendingTranscription && pendingLLMResponse) {
       // Check if we've already processed this exact pair (using ref for synchronous check)
       const lastPair = lastProcessedPairRef.current;
@@ -243,13 +277,6 @@ export function AppProvider({ children }: AppProviderProps) {
         return;
       }
 
-      const lastUserMessage = currentState.chatHistory
-        .filter((m) => m.role === 'learner')
-        .pop();
-      const lastTeacherMessage = currentState.chatHistory
-        .filter((m) => m.role === 'teacher')
-        .pop();
-
       const isDuplicate =
         lastUserMessage?.content === pendingTranscription &&
         lastTeacherMessage?.content === pendingLLMResponse;
@@ -265,9 +292,6 @@ export function AppProvider({ children }: AppProviderProps) {
       const teacherAlreadyAdded = lastTeacherMessage?.content === pendingLLMResponse;
       const userAlreadyAdded = lastUserMessage?.content === pendingTranscription;
 
-      const storage = storageRef.current;
-      const wsClient = wsClientRef.current;
-
       // Mark this pair as processed BEFORE adding (synchronous protection)
       lastProcessedPairRef.current = { user: pendingTranscription, teacher: pendingLLMResponse };
 
@@ -287,17 +311,23 @@ export function AppProvider({ children }: AppProviderProps) {
         return;
       }
 
-      storage.addMessage('user', pendingTranscription);
-      storage.addMessage('assistant', pendingLLMResponse);
+      // Add user message only if not already added
+      if (!userAlreadyAdded) {
+        storage.addMessage('user', pendingTranscription);
+        dispatch({
+          type: 'ADD_MESSAGE',
+          payload: { role: 'learner', content: pendingTranscription },
+        });
+      }
 
-      dispatch({
-        type: 'ADD_MESSAGE',
-        payload: { role: 'learner', content: pendingTranscription },
-      });
-      dispatch({
-        type: 'ADD_MESSAGE',
-        payload: { role: 'teacher', content: pendingLLMResponse },
-      });
+      // Add teacher message only if not already added
+      if (!teacherAlreadyAdded) {
+        storage.addMessage('assistant', pendingLLMResponse);
+        dispatch({
+          type: 'ADD_MESSAGE',
+          payload: { role: 'teacher', content: pendingLLMResponse },
+        });
+      }
 
       const conversationHistory = storage.getConversationHistory();
       wsClient.send({ type: 'conversation_update', data: conversationHistory });
@@ -405,10 +435,18 @@ export function AppProvider({ children }: AppProviderProps) {
       const text = (data as { text: string }).text;
       audioPlayer.stop();
 
-      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
       dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
       dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
 
+      // Check if this transcription was already added (e.g., by sendTextMessage)
+      const alreadyAdded = lastPendingTranscriptionRef.current === text;
+      
+      if (!alreadyAdded) {
+        // Only set pending transcription for audio-based transcriptions
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
+        lastPendingTranscriptionRef.current = text;
+      }
+
       if (
         pendingLLMResponseRef.current &&
         !stateRef.current.streamingLLMResponse
@@ -427,11 +465,9 @@ export function AppProvider({ children }: AppProviderProps) {
 
       dispatch({ type: 'RESET_STREAMING_STATE' });
 
-      if (lastPendingTranscriptionRef.current !== text) {
-        lastPendingTranscriptionRef.current = text;
+      if (!alreadyAdded) {
+        checkAndUpdateConversationRef.current();
       }
-
-      checkAndUpdateConversationRef.current();
     });
 
     wsClient.on('llm_response_chunk', (data) => {
@@ -448,6 +484,10 @@ export function AppProvider({ children }: AppProviderProps) {
       const finalText =
         (data as { text?: string }).text || stateRef.current.streamingLLMResponse;
       dispatch({ type: 'SET_STREAMING_LLM_RESPONSE', payload: finalText });
+
+      // Store the LLM response and trigger conversation update
+      pendingLLMResponseRef.current = finalText;
+      checkAndUpdateConversationRef.current();
     });
 
     wsClient.on('audio_stream', (data) => {
@@ -612,6 +652,32 @@ export function AppProvider({ children }: AppProviderProps) {
     [state.isRecording, state.connectionStatus]
   );
 
+  // Send text message (bypasses audio/STT)
+  const sendTextMessage = useCallback(
+    (text: string) => {
+      const wsClient = wsClientRef.current;
+      const storage = storageRef.current;
+      const trimmedText = text.trim();
+
+      if (!trimmedText || state.connectionStatus !== 'connected') return;
+
+      // Add user message to chat history immediately (unlike audio where we wait for transcription)
+      storage.addMessage('user', trimmedText);
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'learner', content: trimmedText },
+      });
+
+      // Track this as the last pending transcription so we don't duplicate it
+      // when the backend sends back the transcription event
+      lastPendingTranscriptionRef.current = trimmedText;
+
+      // Send to backend
+      wsClient.send({ type: 'text_message', text: trimmedText });
+    },
+    [state.connectionStatus]
+  );
+
   const value: AppContextType = {
     state,
     dispatch,
@@ -623,6 +689,7 @@ export function AppProvider({ children }: AppProviderProps) {
     restartConversation,
     changeLanguage,
     handleInterrupt,
+    sendTextMessage,
   };
 
   return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
diff --git a/frontend/src/hooks/useTypewriter.ts b/frontend/src/hooks/useTypewriter.ts
deleted file mode 100644
index 77459dd..0000000
--- a/frontend/src/hooks/useTypewriter.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { useState, useEffect, useRef } from 'react';
-
-interface UseTypewriterOptions {
-  speed?: number;
-  onComplete?: () => void;
-  onContentUpdate?: () => void;
-}
-
-export function useTypewriter(
-  text: string,
-  options: UseTypewriterOptions = {}
-) {
-  const { speed = 25, onComplete, onContentUpdate } = options;
-  const [displayedText, setDisplayedText] = useState('');
-  const [isTyping, setIsTyping] = useState(false);
-  const onCompleteRef = useRef(onComplete);
-  const onContentUpdateRef = useRef(onContentUpdate);
-  const hasCompletedRef = useRef(false);
-
-  // Keep callback refs up to date
-  useEffect(() => {
-    onCompleteRef.current = onComplete;
-  }, [onComplete]);
-
-  useEffect(() => {
-    onContentUpdateRef.current = onContentUpdate;
-  }, [onContentUpdate]);
-
-  useEffect(() => {
-    if (!text) {
-      setDisplayedText('');
-      setIsTyping(false);
-      hasCompletedRef.current = false;
-      return;
-    }
-
-    setIsTyping(true);
-    hasCompletedRef.current = false;
-    let index = 0;
-
-    const timer = setInterval(() => {
-      if (index < text.length) {
-        setDisplayedText(text.substring(0, index + 1));
-        index++;
-        // Notify parent of content update for scrolling
-        onContentUpdateRef.current?.();
-      } else {
-        clearInterval(timer);
-        setIsTyping(false);
-        if (!hasCompletedRef.current) {
-          hasCompletedRef.current = true;
-          onCompleteRef.current?.();
-        }
-      }
-    }, speed);
-
-    return () => {
-      clearInterval(timer);
-    };
-  }, [text, speed]);
-
-  return { displayedText, isTyping };
-}
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 066e468..9e0ae96 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -322,34 +322,79 @@ body {
     }
 }
 
-.streaming-cursor {
-    animation: blink 1s infinite;
-    color: #6b7280;
-    margin-left: 2px;
+.current-transcript {
+    display: none;
 }
 
-@keyframes blink {
-    0%, 50% { opacity: 1; }
-    51%, 100% { opacity: 0; }
+/* Text Input Form */
+.text-input-form {
+    display: flex;
+    gap: 8px;
+    padding-top: 16px;
+    border-top: 1px solid #e5e5e5;
+    margin-top: 16px;
 }
 
-.current-transcript {
-    display: none;
-    /* padding: 12px 16px;
+.text-input {
+    flex: 1;
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 15px;
+    padding: 12px 16px;
+    border: 1px solid #e5e5e5;
+    border-radius: 24px;
     background: #f9fafb;
-    border: 1px dashed #d1d5db;
-    border-radius: 8px;
-    font-size: 14px;
-    color: #6b7280;
-    font-style: italic;
-    min-height: 44px;
+    color: #1a1a1a;
+    transition: all 0.2s ease;
+}
+
+.text-input:hover:not(:disabled) {
+    border-color: #d1d5db;
+}
+
+.text-input:focus {
+    outline: none;
+    border-color: #1a1a1a;
+    background: #ffffff;
+    box-shadow: 0 0 0 2px rgba(26, 26, 26, 0.1);
+}
+
+.text-input:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.text-input::placeholder {
+    color: #9ca3af;
+}
+
+.send-button {
+    width: 44px;
+    height: 44px;
+    border-radius: 22px;
+    border: none;
+    background: #1a1a1a;
+    color: #ffffff;
     display: flex;
-    align-items: center; */
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    flex-shrink: 0;
 }
 
-/* .current-transcript:empty::before {
-    content: "Live transcription will appear here...";
-} */
+.send-button:hover:not(:disabled) {
+    background: #374151;
+    transform: scale(1.05);
+}
+
+.send-button:active:not(:disabled) {
+    transform: scale(0.95);
+}
+
+.send-button:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+}
 
 /* Flashcards Section */
 .flashcards-section {

From 95be6f5041f82389b09cfb2eae555055252bd6b7 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 21:01:44 -0800
Subject: [PATCH 10/49] removed audio debugging code

---
 backend/helpers/audio_utils.ts        | 137 --------------------------
 backend/helpers/connection-manager.ts |   9 +-
 2 files changed, 1 insertion(+), 145 deletions(-)

diff --git a/backend/helpers/audio_utils.ts b/backend/helpers/audio_utils.ts
index de69e95..a669e2d 100644
--- a/backend/helpers/audio_utils.ts
+++ b/backend/helpers/audio_utils.ts
@@ -2,143 +2,6 @@
  * Audio utility functions for format conversion
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Audio debug logging
-const DEBUG_AUDIO = process.env.DEBUG_AUDIO === 'true';
-const AUDIO_DEBUG_DIR = path.join(process.cwd(), 'audio-debug');
-
-// Ensure debug directory exists
-if (DEBUG_AUDIO && !fs.existsSync(AUDIO_DEBUG_DIR)) {
-  fs.mkdirSync(AUDIO_DEBUG_DIR, { recursive: true });
-  console.log(`[AudioDebug] Created debug directory: ${AUDIO_DEBUG_DIR}`);
-}
-
-// Audio buffer for accumulating chunks per session
-const audioBuffers: Map<string, Float32Array[]> = new Map();
-
-/**
- * Add audio chunk to debug buffer
- */
-export function debugAddAudioChunk(sessionId: string, float32Data: Float32Array): void {
-  if (!DEBUG_AUDIO) return;
-
-  if (!audioBuffers.has(sessionId)) {
-    audioBuffers.set(sessionId, []);
-    console.log(`[AudioDebug] Started collecting audio for session ${sessionId}`);
-  }
-
-  audioBuffers.get(sessionId)!.push(new Float32Array(float32Data));
-}
-
-/**
- * Save accumulated audio to WAV file
- */
-export function debugSaveAudio(sessionId: string, sampleRate: number = 16000): string | null {
-  if (!DEBUG_AUDIO) return null;
-
-  const chunks = audioBuffers.get(sessionId);
-  if (!chunks || chunks.length === 0) {
-    console.log(`[AudioDebug] No audio to save for session ${sessionId}`);
-    return null;
-  }
-
-  // Combine all chunks
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const combined = new Float32Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    combined.set(chunk, offset);
-    offset += chunk.length;
-  }
-
-  // Convert to WAV
-  const wavBuffer = float32ToWav(combined, sampleRate);
-
-  // Save to file
-  const filename = `audio_${sessionId}_${Date.now()}.wav`;
-  const filepath = path.join(AUDIO_DEBUG_DIR, filename);
-  fs.writeFileSync(filepath, wavBuffer);
-
-  console.log(`[AudioDebug] Saved ${combined.length} samples (${(combined.length / sampleRate).toFixed(2)}s) to ${filepath}`);
-
-  // Clear buffer
-  audioBuffers.delete(sessionId);
-
-  return filepath;
-}
-
-/**
- * Log audio stats for debugging
- * Note: Uses loop instead of spread operator to avoid stack overflow on large arrays
- */
-export function debugLogAudioStats(sessionId: string, float32Data: Float32Array): void {
-  if (!DEBUG_AUDIO) return;
-
-  // Calculate stats using loops to avoid blocking with large arrays
-  let min = Infinity;
-  let max = -Infinity;
-  let sum = 0;
-  let nonZero = 0;
-  for (let i = 0; i < float32Data.length; i++) {
-    const v = float32Data[i];
-    if (v < min) min = v;
-    if (v > max) max = v;
-    sum += v;
-    if (Math.abs(v) > 0.001) nonZero++;
-  }
-  const avg = sum / float32Data.length;
-
-  console.log(`[AudioDebug] Session ${sessionId.slice(-8)}: samples=${float32Data.length}, min=${min.toFixed(4)}, max=${max.toFixed(4)}, avg=${avg.toFixed(4)}, nonZero=${nonZero}/${float32Data.length}`);
-}
-
-/**
- * Convert Float32 audio to WAV buffer
- */
-function float32ToWav(samples: Float32Array, sampleRate: number): Buffer {
-  const numChannels = 1;
-  const bitsPerSample = 16;
-  const bytesPerSample = bitsPerSample / 8;
-  const blockAlign = numChannels * bytesPerSample;
-  const byteRate = sampleRate * blockAlign;
-  const dataSize = samples.length * bytesPerSample;
-  const headerSize = 44;
-  const totalSize = headerSize + dataSize;
-
-  const buffer = Buffer.alloc(totalSize);
-  let offset = 0;
-
-  // RIFF header
-  buffer.write('RIFF', offset); offset += 4;
-  buffer.writeUInt32LE(totalSize - 8, offset); offset += 4;
-  buffer.write('WAVE', offset); offset += 4;
-
-  // fmt chunk
-  buffer.write('fmt ', offset); offset += 4;
-  buffer.writeUInt32LE(16, offset); offset += 4; // chunk size
-  buffer.writeUInt16LE(1, offset); offset += 2; // PCM format
-  buffer.writeUInt16LE(numChannels, offset); offset += 2;
-  buffer.writeUInt32LE(sampleRate, offset); offset += 4;
-  buffer.writeUInt32LE(byteRate, offset); offset += 4;
-  buffer.writeUInt16LE(blockAlign, offset); offset += 2;
-  buffer.writeUInt16LE(bitsPerSample, offset); offset += 2;
-
-  // data chunk
-  buffer.write('data', offset); offset += 4;
-  buffer.writeUInt32LE(dataSize, offset); offset += 4;
-
-  // Write samples as 16-bit PCM
-  for (let i = 0; i < samples.length; i++) {
-    const s = Math.max(-1, Math.min(1, samples[i]));
-    const val = s < 0 ? s * 0x8000 : s * 0x7FFF;
-    buffer.writeInt16LE(Math.round(val), offset);
-    offset += 2;
-  }
-
-  return buffer;
-}
-
 /**
  * Convert Float32Array audio data to Int16Array (PCM16)
  */
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index e69fd07..d9471ed 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -13,7 +13,7 @@ import { GraphTypes } from '@inworld/runtime/graph';
 
 import { ConversationGraphWrapper } from '../graphs/conversation-graph.js';
 import { MultimodalStreamManager } from './multimodal_stream_manager.js';
-import { decodeBase64ToFloat32, debugAddAudioChunk, debugLogAudioStats, debugSaveAudio } from './audio_utils.js';
+import { decodeBase64ToFloat32 } from './audio_utils.js';
 import { ConnectionsMap, INPUT_SAMPLE_RATE, TTS_SAMPLE_RATE } from '../types/index.js';
 import {
   getLanguageConfig,
@@ -318,10 +318,6 @@ export class ConnectionManager {
       // Decode base64 to Float32Array
       const float32Data = decodeBase64ToFloat32(base64Audio);
 
-      // Debug: log audio stats and collect for WAV export
-      debugLogAudioStats(this.sessionId, float32Data);
-      debugAddAudioChunk(this.sessionId, float32Data);
-
       // Push to multimodal stream - pass Float32Array directly,
       // MultimodalStreamManager will handle conversion when needed
       this.multimodalStreamManager.pushAudio({
@@ -513,9 +509,6 @@ export class ConnectionManager {
     console.log(`[ConnectionManager] Destroying session ${this.sessionId}`);
     this.isDestroyed = true;
 
-    // Save debug audio if enabled (DEBUG_AUDIO=true)
-    debugSaveAudio(this.sessionId, INPUT_SAMPLE_RATE);
-
     // End the multimodal stream
     this.multimodalStreamManager.end();
 

From 18c37b9eede5e447352ea434be038dd51aa5c60e Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 21:09:08 -0800
Subject: [PATCH 11/49] filename consistency with kebab case

---
 backend/graphs/conversation-graph.ts               | 14 +++++++-------
 ...i_stt_ws_node.ts => assembly-ai-stt-ws-node.ts} |  3 ++-
 ...ilder_node.ts => dialog-prompt-builder-node.ts} |  1 +
 ...ion_queue_node.ts => interaction-queue-node.ts} |  1 +
 .../{state_update_node.ts => state-update-node.ts} |  1 +
 .../{text_input_node.ts => text-input-node.ts}     |  1 +
 ...ractor_node.ts => transcript-extractor-node.ts} |  1 +
 ...builder_node.ts => tts-request-builder-node.ts} |  1 +
 backend/helpers/{audio_utils.ts => audio-utils.ts} |  1 +
 backend/helpers/connection-manager.ts              |  4 ++--
 ...eam_manager.ts => multimodal-stream-manager.ts} |  1 +
 backend/types/index.ts                             |  2 +-
 12 files changed, 20 insertions(+), 11 deletions(-)
 rename backend/graphs/nodes/{assembly_ai_stt_ws_node.ts => assembly-ai-stt-ws-node.ts} (99%)
 rename backend/graphs/nodes/{dialog_prompt_builder_node.ts => dialog-prompt-builder-node.ts} (99%)
 rename backend/graphs/nodes/{interaction_queue_node.ts => interaction-queue-node.ts} (99%)
 rename backend/graphs/nodes/{state_update_node.ts => state-update-node.ts} (99%)
 rename backend/graphs/nodes/{text_input_node.ts => text-input-node.ts} (99%)
 rename backend/graphs/nodes/{transcript_extractor_node.ts => transcript-extractor-node.ts} (99%)
 rename backend/graphs/nodes/{tts_request_builder_node.ts => tts-request-builder-node.ts} (99%)
 rename backend/helpers/{audio_utils.ts => audio-utils.ts} (99%)
 rename backend/helpers/{multimodal_stream_manager.ts => multimodal-stream-manager.ts} (99%)

diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index ec060c3..2b8687c 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -23,13 +23,13 @@ import {
   TextAggregatorNode,
 } from '@inworld/runtime/graph';
 
-import { AssemblyAISTTWebSocketNode } from './nodes/assembly_ai_stt_ws_node.js';
-import { DialogPromptBuilderNode } from './nodes/dialog_prompt_builder_node.js';
-import { InteractionQueueNode } from './nodes/interaction_queue_node.js';
-import { StateUpdateNode } from './nodes/state_update_node.js';
-import { TextInputNode } from './nodes/text_input_node.js';
-import { TranscriptExtractorNode } from './nodes/transcript_extractor_node.js';
-import { TTSRequestBuilderNode } from './nodes/tts_request_builder_node.js';
+import { AssemblyAISTTWebSocketNode } from './nodes/assembly-ai-stt-ws-node.js';
+import { DialogPromptBuilderNode } from './nodes/dialog-prompt-builder-node.js';
+import { InteractionQueueNode } from './nodes/interaction-queue-node.js';
+import { StateUpdateNode } from './nodes/state-update-node.js';
+import { TextInputNode } from './nodes/text-input-node.js';
+import { TranscriptExtractorNode } from './nodes/transcript-extractor-node.js';
+import { TTSRequestBuilderNode } from './nodes/tts-request-builder-node.js';
 import {
   ConnectionsMap,
   TextInput,
diff --git a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
similarity index 99%
rename from backend/graphs/nodes/assembly_ai_stt_ws_node.ts
rename to backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index 8db92cc..1f7162a 100644
--- a/backend/graphs/nodes/assembly_ai_stt_ws_node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -4,7 +4,7 @@ import WebSocket from 'ws';
 import { v4 as uuidv4 } from 'uuid';
 
 import { Connection } from '../../types/index.js';
-import { audioDataToPCM16 } from '../../helpers/audio_utils.js';
+import { audioDataToPCM16 } from '../../helpers/audio-utils.js';
 
 /**
  * Configuration interface for AssemblyAISTTWebSocketNode
@@ -595,3 +595,4 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.sessions.clear();
   }
 }
+
diff --git a/backend/graphs/nodes/dialog_prompt_builder_node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
similarity index 99%
rename from backend/graphs/nodes/dialog_prompt_builder_node.ts
rename to backend/graphs/nodes/dialog-prompt-builder-node.ts
index d035b35..a378b0f 100644
--- a/backend/graphs/nodes/dialog_prompt_builder_node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -82,3 +82,4 @@ export class DialogPromptBuilderNode extends CustomNode {
     });
   }
 }
+
diff --git a/backend/graphs/nodes/interaction_queue_node.ts b/backend/graphs/nodes/interaction-queue-node.ts
similarity index 99%
rename from backend/graphs/nodes/interaction_queue_node.ts
rename to backend/graphs/nodes/interaction-queue-node.ts
index ae345d2..d6ec1e8 100644
--- a/backend/graphs/nodes/interaction_queue_node.ts
+++ b/backend/graphs/nodes/interaction-queue-node.ts
@@ -165,3 +165,4 @@ export class InteractionQueueNode extends CustomNode {
     }
   }
 }
+
diff --git a/backend/graphs/nodes/state_update_node.ts b/backend/graphs/nodes/state-update-node.ts
similarity index 99%
rename from backend/graphs/nodes/state_update_node.ts
rename to backend/graphs/nodes/state-update-node.ts
index 23f7fed..ec1ccf6 100644
--- a/backend/graphs/nodes/state_update_node.ts
+++ b/backend/graphs/nodes/state-update-node.ts
@@ -66,3 +66,4 @@ export class StateUpdateNode extends CustomNode {
     return connection.state;
   }
 }
+
diff --git a/backend/graphs/nodes/text_input_node.ts b/backend/graphs/nodes/text-input-node.ts
similarity index 99%
rename from backend/graphs/nodes/text_input_node.ts
rename to backend/graphs/nodes/text-input-node.ts
index fd91f6a..c3b550f 100644
--- a/backend/graphs/nodes/text_input_node.ts
+++ b/backend/graphs/nodes/text-input-node.ts
@@ -59,3 +59,4 @@ export class TextInputNode extends CustomNode {
     return connection.state;
   }
 }
+
diff --git a/backend/graphs/nodes/transcript_extractor_node.ts b/backend/graphs/nodes/transcript-extractor-node.ts
similarity index 99%
rename from backend/graphs/nodes/transcript_extractor_node.ts
rename to backend/graphs/nodes/transcript-extractor-node.ts
index 1b47e1c..6644750 100644
--- a/backend/graphs/nodes/transcript_extractor_node.ts
+++ b/backend/graphs/nodes/transcript-extractor-node.ts
@@ -49,3 +49,4 @@ export class TranscriptExtractorNode extends CustomNode {
     // No cleanup needed
   }
 }
+
diff --git a/backend/graphs/nodes/tts_request_builder_node.ts b/backend/graphs/nodes/tts-request-builder-node.ts
similarity index 99%
rename from backend/graphs/nodes/tts_request_builder_node.ts
rename to backend/graphs/nodes/tts-request-builder-node.ts
index df1caa4..5f40266 100644
--- a/backend/graphs/nodes/tts_request_builder_node.ts
+++ b/backend/graphs/nodes/tts-request-builder-node.ts
@@ -62,3 +62,4 @@ export class TTSRequestBuilderNode extends CustomNode {
     // No cleanup needed
   }
 }
+
diff --git a/backend/helpers/audio_utils.ts b/backend/helpers/audio-utils.ts
similarity index 99%
rename from backend/helpers/audio_utils.ts
rename to backend/helpers/audio-utils.ts
index a669e2d..6021943 100644
--- a/backend/helpers/audio_utils.ts
+++ b/backend/helpers/audio-utils.ts
@@ -85,3 +85,4 @@ export function decodeBase64ToFloat32(base64Audio: string): Float32Array {
   // Interpret bytes directly as Float32 (4 bytes per sample)
   return new Float32Array(cleanArray.buffer);
 }
+
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index d9471ed..bb0243d 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -12,8 +12,8 @@ import { WebSocket } from 'ws';
 import { GraphTypes } from '@inworld/runtime/graph';
 
 import { ConversationGraphWrapper } from '../graphs/conversation-graph.js';
-import { MultimodalStreamManager } from './multimodal_stream_manager.js';
-import { decodeBase64ToFloat32 } from './audio_utils.js';
+import { MultimodalStreamManager } from './multimodal-stream-manager.js';
+import { decodeBase64ToFloat32 } from './audio-utils.js';
 import { ConnectionsMap, INPUT_SAMPLE_RATE, TTS_SAMPLE_RATE } from '../types/index.js';
 import {
   getLanguageConfig,
diff --git a/backend/helpers/multimodal_stream_manager.ts b/backend/helpers/multimodal-stream-manager.ts
similarity index 99%
rename from backend/helpers/multimodal_stream_manager.ts
rename to backend/helpers/multimodal-stream-manager.ts
index 175bec8..5311e8d 100644
--- a/backend/helpers/multimodal_stream_manager.ts
+++ b/backend/helpers/multimodal-stream-manager.ts
@@ -135,3 +135,4 @@ export class MultimodalStreamManager {
     return this.queue.length;
   }
 }
+
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 470925a..ba817bf 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -3,7 +3,7 @@
  */
 
 import { WebSocket } from 'ws';
-import type { MultimodalStreamManager } from '../helpers/multimodal_stream_manager.js';
+import type { MultimodalStreamManager } from '../helpers/multimodal-stream-manager.js';
 import type { GraphOutputStream } from '@inworld/runtime/graph';
 
 /**

From 1afce2a020c407f37b0d298eb580e049733f9da4 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 22:23:25 -0800
Subject: [PATCH 12/49] added pause and interruption handling

---
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   |  23 ++-
 backend/helpers/connection-manager.ts         | 179 ++++++++++++++----
 backend/types/index.ts                        |   3 +
 frontend/src/context/AppContext.tsx           |  42 +++-
 frontend/src/services/WebSocketClient.ts      |   8 +
 5 files changed, 216 insertions(+), 39 deletions(-)

diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index 1f7162a..fc9be2d 100644
--- a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -381,13 +381,28 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             return;
           }
 
-          // Final transcript
-          console.log(`[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
+          // Final transcript - check for pending transcript to stitch
+          let finalTranscript = transcript;
+
+          if (connection?.pendingTranscript) {
+            // Stitch the pending transcript with the new one
+            finalTranscript = `${connection.pendingTranscript} ${transcript}`.trim();
+            console.log(`[AssemblyAI] Stitched transcript [iteration:${iteration}]: "${finalTranscript.substring(0, 80)}..."`);
+            // Clear the pending transcript
+            connection.pendingTranscript = undefined;
+          } else {
+            console.log(`[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
+          }
+
+          // Clear interrupt flag for new processing
+          if (connection) {
+            connection.isProcessingInterrupted = false;
+          }
 
-          transcriptText = transcript;
+          transcriptText = finalTranscript;
           turnDetected = true;
           if (session) session.shouldStopProcessing = true;
-          turnResolve(transcript);
+          turnResolve(finalTranscript);
 
         } else if (msgType === 'Termination') {
           console.log(`[AssemblyAI] Session terminated [iteration:${iteration}]`);
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index bb0243d..b54e6b8 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -37,6 +37,10 @@ export class ConnectionManager {
     | ((messages: Array<{ role: string; content: string }>) => Promise<void>)
     | null = null;
 
+  // Processing state tracking for utterance stitching
+  private isProcessingResponse: boolean = false;
+  private currentTranscript: string = '';
+
   constructor(
     sessionId: string,
     ws: WebSocket,
@@ -194,6 +198,10 @@ export class ConnectionManager {
           if (data.text && data.interactionComplete) {
             transcription = data.text;
             console.log(`[ConnectionManager] Transcription (final): "${transcription}"`);
+
+            // Mark start of response processing for utterance stitching
+            this.markProcessingStart(transcription);
+
             this.sendToClient({
               type: 'transcription',
               text: transcription.trim(),
@@ -208,9 +216,18 @@ export class ConnectionManager {
           console.log('[ConnectionManager] Processing LLM ContentStream...');
           // Use array + join instead of string concatenation for O(n) vs O(n²)
           const responseChunks: string[] = [];
+          let wasInterrupted = false;
 
           for await (const chunk of stream) {
             if (this.isDestroyed) break;
+
+            // Check for interruption (user started speaking again for continuation)
+            if (connection.isProcessingInterrupted) {
+              console.log('[ConnectionManager] LLM stream interrupted for utterance continuation');
+              wasInterrupted = true;
+              break;
+            }
+
             if (chunk.text) {
               responseChunks.push(chunk.text);
               this.sendToClient({
@@ -221,17 +238,22 @@ export class ConnectionManager {
             }
           }
 
-          const currentResponse = responseChunks.join('');
-          if (currentResponse.trim()) {
-            llmResponse = currentResponse;
-            console.log(
-              `[ConnectionManager] LLM Response complete: "${llmResponse.substring(0, 50)}..."`
-            );
-            this.sendToClient({
-              type: 'llm_response_complete',
-              text: llmResponse.trim(),
-              timestamp: Date.now(),
-            });
+          // Only send completion if not interrupted
+          if (!wasInterrupted) {
+            const currentResponse = responseChunks.join('');
+            if (currentResponse.trim()) {
+              llmResponse = currentResponse;
+              console.log(
+                `[ConnectionManager] LLM Response complete: "${llmResponse.substring(0, 50)}..."`
+              );
+              this.sendToClient({
+                type: 'llm_response_complete',
+                text: llmResponse.trim(),
+                timestamp: Date.now(),
+              });
+            }
+          } else {
+            console.log('[ConnectionManager] LLM stream interrupted - skipping response complete');
           }
         },
 
@@ -240,9 +262,18 @@ export class ConnectionManager {
           const ttsStream = ttsData as GraphTypes.TTSOutputStream;
           console.log('[ConnectionManager] Processing TTS stream...');
           let isFirstChunk = true;
+          let wasInterrupted = false;
 
           for await (const chunk of ttsStream) {
             if (this.isDestroyed) break;
+
+            // Check for interruption (user started speaking again for continuation)
+            if (connection.isProcessingInterrupted) {
+              console.log('[ConnectionManager] TTS interrupted for utterance continuation');
+              wasInterrupted = true;
+              break;
+            }
+
             if (chunk.audio?.data) {
               // Log sample rate on first chunk
               if (isFirstChunk) {
@@ -267,22 +298,30 @@ export class ConnectionManager {
             }
           }
 
-          // Send completion signal
-          console.log('[ConnectionManager] TTS stream complete');
-          this.sendToClient({
-            type: 'audio_stream_complete',
-            timestamp: Date.now(),
-          });
-
-          // Send conversation update
-          this.sendToClient({
-            type: 'conversation_update',
-            messages: connection.state.messages,
-            timestamp: Date.now(),
-          });
-
-          // Trigger flashcard generation after TTS completes
-          this.triggerFlashcardGeneration();
+          // Mark processing complete (even if interrupted)
+          this.markProcessingComplete();
+
+          // Only send completion signals if not interrupted
+          if (!wasInterrupted) {
+            // Send completion signal
+            console.log('[ConnectionManager] TTS stream complete');
+            this.sendToClient({
+              type: 'audio_stream_complete',
+              timestamp: Date.now(),
+            });
+
+            // Send conversation update
+            this.sendToClient({
+              type: 'conversation_update',
+              messages: connection.state.messages,
+              timestamp: Date.now(),
+            });
+
+            // Trigger flashcard generation after TTS completes
+            this.triggerFlashcardGeneration();
+          } else {
+            console.log('[ConnectionManager] TTS stream interrupted - skipping completion signals');
+          }
         },
 
         // Handle errors
@@ -334,18 +373,34 @@ export class ConnectionManager {
    */
   private handleSpeechDetected(interactionId: string): void {
     console.log(`[ConnectionManager] Speech detected: ${interactionId}`);
+
+    // Check if we're currently processing a response - if so, this is a continuation
+    if (this.isProcessingResponse && this.currentTranscript) {
+      console.log(`[ConnectionManager] New speech during processing - interrupting for continuation`);
+      this.interruptForContinuation(this.currentTranscript);
+
+      // Send interrupt signal with continuation reason so frontend discards partial response
+      this.sendToClient({
+        type: 'interrupt',
+        reason: 'continuation_detected',
+        timestamp: Date.now(),
+      });
+    } else {
+      // Normal case - send regular interrupt signal
+      this.sendToClient({
+        type: 'interrupt',
+        reason: 'speech_start',
+        timestamp: Date.now(),
+      });
+    }
+
+    // Always send speech_detected for UI feedback
     this.sendToClient({
       type: 'speech_detected',
       interactionId,
       data: { text: '' },
       timestamp: Date.now(),
     });
-
-    // Could also send interrupt signal here if needed
-    this.sendToClient({
-      type: 'interrupt',
-      reason: 'speech_start',
-    });
   }
 
   /**
@@ -360,6 +415,64 @@ export class ConnectionManager {
     });
   }
 
+  /**
+   * Interrupt current processing for utterance continuation/stitching.
+   * Called when user starts speaking again while we're processing the first utterance.
+   */
+  private interruptForContinuation(partialTranscript: string): void {
+    const connection = this.connections[this.sessionId];
+    if (connection) {
+      connection.isProcessingInterrupted = true;
+      connection.pendingTranscript = partialTranscript;
+      console.log(`[ConnectionManager] Interrupting for continuation. Stored: "${partialTranscript.substring(0, 50)}..."`);
+
+      // Remove the last user message and any assistant response that was added
+      // before the continuation was detected
+      const messages = connection.state.messages;
+      let removedCount = 0;
+
+      // Remove the last assistant message if it exists (the interrupted response)
+      if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+        const removed = messages.pop();
+        removedCount++;
+        console.log(`[ConnectionManager] Removed interrupted assistant message: "${removed?.content.substring(0, 50)}..."`);
+      }
+
+      // Remove the last user message (the partial utterance that will be stitched)
+      if (messages.length > 0 && messages[messages.length - 1].role === 'user') {
+        const removed = messages.pop();
+        removedCount++;
+        console.log(`[ConnectionManager] Removed partial user message: "${removed?.content.substring(0, 50)}..."`);
+      }
+
+      // Notify frontend to update its conversation history
+      if (removedCount > 0) {
+        this.sendToClient({
+          type: 'conversation_rollback',
+          removedCount,
+          messages: messages,
+          timestamp: Date.now(),
+        });
+      }
+    }
+  }
+
+  /**
+   * Mark the start of response processing (LLM/TTS)
+   */
+  private markProcessingStart(transcript: string): void {
+    this.isProcessingResponse = true;
+    this.currentTranscript = transcript;
+  }
+
+  /**
+   * Mark the end of response processing
+   */
+  private markProcessingComplete(): void {
+    this.isProcessingResponse = false;
+    this.currentTranscript = '';
+  }
+
   /**
    * Convert audio data to base64 string for WebSocket transmission
    * Inworld TTS returns Float32 PCM in [-1.0, 1.0] range - send directly to preserve quality
diff --git a/backend/types/index.ts b/backend/types/index.ts
index ba817bf..5f5aad0 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -44,6 +44,9 @@ export interface Connection {
   currentAudioExecutionStream?: GraphOutputStream;
   onSpeechDetected?: (interactionId: string) => void;
   onPartialTranscript?: (text: string, interactionId: string) => void;
+  // Utterance stitching support
+  pendingTranscript?: string; // Stores transcript from interrupted turn for stitching
+  isProcessingInterrupted?: boolean; // Flag to stop current LLM/TTS processing
 }
 
 /**
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 5f89672..4d31b03 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -504,8 +504,46 @@ export function AppProvider({ children }: AppProviderProps) {
       audioPlayer.markStreamComplete();
     });
 
-    wsClient.on('interrupt', () => {
-      handleInterruptRef.current();
+    wsClient.on('interrupt', (data) => {
+      const reason = (data as { reason?: string })?.reason;
+
+      if (reason === 'continuation_detected') {
+        // User is continuing their utterance - discard partial response silently
+        console.log('[AppContext] Continuation detected - discarding partial response');
+        audioPlayer.stop();
+        // Don't save the partial response - just reset streaming state
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        pendingLLMResponseRef.current = null;
+      } else {
+        // Normal interrupt (speech_start) - use regular interrupt handling
+        handleInterruptRef.current();
+      }
+    });
+
+    wsClient.on('conversation_rollback', (data) => {
+      // Server removed messages due to utterance continuation - sync frontend state
+      const { messages, removedCount } = data as { messages: Array<{ role: string; content: string }>; removedCount: number };
+      console.log(`[AppContext] Conversation rollback - removed ${removedCount} messages`);
+
+      // Convert backend format to frontend format
+      const chatHistory = messages.map((m) => ({
+        role: m.role === 'user' ? 'learner' : 'teacher',
+        content: m.content,
+      })) as ChatMessage[];
+
+      // Update chat history to match server state
+      dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+
+      // Also update storage to stay in sync
+      storage.clearConversation();
+      messages.forEach((m) => {
+        storage.addMessage(m.role === 'user' ? 'user' : 'assistant', m.content);
+      });
+
+      // Clear any pending state
+      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+      pendingLLMResponseRef.current = null;
+      lastPendingTranscriptionRef.current = null;
     });
 
     wsClient.on('flashcards_generated', (flashcards) => {
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index fa200a7..256ea48 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -269,6 +269,14 @@ export class WebSocketClient {
         this.emit('interrupt', { reason: message.reason });
         break;
 
+      case 'conversation_rollback':
+        this.emit('conversation_rollback', {
+          messages: message.messages,
+          removedCount: message.removedCount,
+          timestamp: message.timestamp,
+        });
+        break;
+
       case 'language_changed':
         this.emit('language_changed', {
           languageCode: message.languageCode,

From da477ed737065b1b96d8bd901ce9ddd2e55ea0f1 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 22:53:23 -0800
Subject: [PATCH 13/49] renamed app and updated readme

---
 CONTRIBUTING.md                               |   1 +
 README.md                                     |  38 +++++++++++-------
 backend/helpers/anki-exporter.ts              |   4 +-
 backend/helpers/prompt-templates.ts           |   2 +-
 backend/models/silero_vad.onnx                | Bin 2327524 -> 0 bytes
 backend/server.ts                             |   4 +-
 frontend/index.html                           |   4 +-
 frontend/public/favicon.svg                   |   1 +
 frontend/public/vite.svg                      |   1 -
 frontend/src/components/FlashcardsSection.tsx |   4 +-
 frontend/src/components/Header.tsx            |   2 +-
 11 files changed, 35 insertions(+), 26 deletions(-)
 delete mode 100644 backend/models/silero_vad.onnx
 create mode 100644 frontend/public/favicon.svg
 delete mode 100644 frontend/public/vite.svg

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c024b46..563af65 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -33,6 +33,7 @@ Thank you for your interest in contributing to the Language Learning App! This d
 
    ```bash
    INWORLD_API_KEY=your_api_key_here
+   ASSEMBLY_AI_API_KEY=your_api_key_here
    ```
 
 5. **Verify the setup**:
diff --git a/README.md b/README.md
index 92c0284..55e4f80 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,11 @@
-# Language Learning - Aprendemo
+# Inworld Language Tutor
 
 [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
 [![Powered by Inworld AI](https://img.shields.io/badge/Powered_by-Inworld_AI-orange)](https://inworld.ai/runtime)
 [![Documentation](https://img.shields.io/badge/Documentation-Read_Docs-blue)](https://docs.inworld.ai/docs/node/overview)
 [![Model Providers](https://img.shields.io/badge/Model_Providers-See_Models-purple)](https://docs.inworld.ai/docs/models#llm)
 
-A Node.js app where you can learn Spanish through conversation and flashcard studying, powered by Inworld AI Runtime. "Aprendemo" combines "Aprender" (Spanish for "to learn") with "demo" - it's both a language learning tool and a demonstration of the Inworld Runtime Node.js SDK.
+A Node.js app where you can learn languages through conversation and flashcard studying, powered by Inworld AI Runtime. This is a demonstration of the Inworld Runtime Node.js SDK.
 
 ![App](screenshot.jpg)
 
@@ -13,6 +13,7 @@ A Node.js app where you can learn Spanish through conversation and flashcard stu
 
 - Node.js (v20 or higher)
 - An Inworld AI account and API key
+- An Assembly AI account and API key
 
 ## Get Started
 
@@ -35,9 +36,10 @@ Create a `.env` file in the root directory:
 
 ```bash
 INWORLD_API_KEY=your_api_key_here
+ASSEMBLY_AI_API_KEY=your_api_key_here
 ```
 
-Get your Base64 API key from the [Inworld Portal](https://platform.inworld.ai/).
+Get your Inworld Base64 API key from the [Inworld Portal](https://platform.inworld.ai/).
 
 ### Step 4: Run the Application
 
@@ -59,26 +61,32 @@ npm start
 ```
 language-learning-node/
 ├── backend/
+│   ├── config/               # Configuration
+│   │   └── languages.ts
 │   ├── graphs/               # Graph definitions
+│   │   ├── nodes/            # Graph node implementations
 │   │   ├── conversation-graph.ts
-│   │   ├── flashcard-graph.ts
-│   │   └── introduction-state-graph.ts
+│   │   └── flashcard-graph.ts
 │   ├── helpers/              # Helper utilities
 │   │   ├── anki-exporter.ts
 │   │   ├── audio-buffer.ts
-│   │   ├── audio-processor.ts
+│   │   ├── audio-utils.ts
+│   │   ├── connection-manager.ts
 │   │   ├── flashcard-processor.ts
-│   │   ├── introduction-state-processor.ts
-│   │   ├── prompt-templates.ts
-│   │   └── silero-vad.ts
-│   ├── models/               # AI models
-│   │   └── silero_vad.onnx
+│   │   ├── multimodal-stream-manager.ts
+│   │   └── prompt-templates.ts
+│   ├── types/                # TypeScript type definitions
 │   └── server.ts             # Backend server
-├── frontend/                 # Frontend application
-│   ├── js/
-│   ├── styles/
+├── frontend/                 # React frontend application
+│   ├── public/               # Static assets
+│   ├── src/
+│   │   ├── components/       # React components
+│   │   ├── context/          # React context providers
+│   │   ├── hooks/            # Custom React hooks
+│   │   ├── services/         # Frontend services
+│   │   ├── styles/           # CSS styles
+│   │   └── types/            # TypeScript type definitions
 │   └── index.html
-├── flashcard-graph.json      # Flashcard configuration
 ├── package.json              # Dependencies
 └── LICENSE                   # MIT License
 ```
diff --git a/backend/helpers/anki-exporter.ts b/backend/helpers/anki-exporter.ts
index 16f47ba..33657b2 100644
--- a/backend/helpers/anki-exporter.ts
+++ b/backend/helpers/anki-exporter.ts
@@ -8,7 +8,7 @@ export class AnkiExporter {
    */
   async exportFlashcards(
     flashcards: Flashcard[],
-    deckName: string = 'Aprendemo Language Cards'
+    deckName: string = 'Inworld Language Tutor Cards'
   ): Promise<Buffer> {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const apkg = new (AnkiExport as any).default(deckName);
@@ -32,7 +32,7 @@ export class AnkiExporter {
       const back = this.formatCardBack(flashcard);
 
       // Add tags for organization
-      const tags = ['aprendemo'];
+      const tags = ['inworld-language-tutor'];
 
       // Add language tag if available
       if (flashcard.languageCode) {
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index 9f582d2..58d0c61 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -14,7 +14,7 @@ export const conversationTemplate = `
 
 # Context
 - You are {{teacher_name}}, {{teacher_description}}.
-- You are embedded in a {{target_language}} learning app called 'Aprendemo', which is a demonstration of the Inworld AI Runtime.
+- You are embedded in a {{target_language}} learning app called 'Inworld Language Tutor', which is a demonstration of the Inworld AI Runtime.
 - You can help the user learn {{target_language}} by having natural (verbalized) conversations with them.
 - The app generates flashcards for the user during the conversation. They are ANKI formatted and can be exported by the user.
 
diff --git a/backend/models/silero_vad.onnx b/backend/models/silero_vad.onnx
deleted file mode 100644
index b3e3a900c0d70e67b5e2b90a33ad856ee7947930..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2327524
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%0A8&}L
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%0A4R@~UWxf0NVHKf1{AyP&
z3-30@jh_YhXk0DpO#BQtm!{&>d9s4L+Sg!x{w=)7yp!?#^5Ej6U$`yjI$PG3fg7`$
zu&j9-<2grS*~y2o=*?qnQ0P4N+!BMwqW`gEL$mVumMr}0#vnUWeIB$WOK|J^6HIIx
z=Oj6E47;hPuqST$bf5`iJ7*nM;klV8C#=RF=bvPCVGmK3el)f!eb2g517W$47C!Kx
zg&k_^;9M*+xNZFmmbx(=Yc!s~Art>Hhq6LAN0adOgICz1Wgp;a^e42%UtAzLDhZ7d
zb8+a!<IG@JKO~ziz!mwg>E<6taM?30EPM1YGYm06mG81~;R+rV;<&my%D66l|7j+5
z#ScF`;D#G~cCe~lwd77M#c#H5WEJVZx!&+MeD3{PHX_L5K8Im&Jdnq#<9x79%bEE-
zBYrIF&wWTLi^0<}2WjLV2Ru$I6c1fI&+4LFaFGncLvz=#o3dAMU9%XTzj`g3v}yo)
z1`c6?+*H;ZWJDFxwqc?0y=+JJGF)B#jhtG<IZM|hBXe$-J#ly|s|eKx^VVpHZduJ9
zDa2s;I7u*nv5@6{TZ0c<&PS1c;;hnk8m_fJMXkQq(xcCGsIdETEV5=7-r$yoo9xHK
z@d6#}G9-@s@6Dy_I0nSxm#T2!mMI8(wozQ61LM*wdD5fz=qA4tu)bQ2?P+8DYBf3B
z*LaVLh;5~FQfFeL>IvXquo=^=3lQ{4k@V@B<Arh(M0T4Fuki)v@VvK)RauPEblZIT
z=;#!-Z}TKF`bw9}uV};H<<n`&0X=4^c^=|QL|8+~VcNZ6F20$X1&7b25T}_xP>e?t
zI@rqX76K}1O5!;ZGOPgP)pTa>_k?N})<XTb6nb&Pd}N|M8;f$zpETY?T=n)QTy?PJ
zuIuF>l*)ZJb3TEe6}I{?cMztU9|Vg;aU3x+kzHF_PeCOL8(xT_h*wK*YVXD$w)`dW
zn}W&es&puRvV>~%9j8X@3uGjJB(ZCAXzHsrblU4W%KVZ**WCRM@mA`LbpHa|_pVr6
zZ$I>uXu=eSgIMpv8)*5ygxw1_!<jl9m*dqsri8+<@SHA`=xxFJ19HK1wh6xR*@KN#
zW#AbV)%Y;iNiodN#|@qN_yBjq*pRvmYb(l7ML{b)8nc1UdzXs!m8Y|x-vil?gdN!6
z)jk&a<qni}uV9c<#zr6bz-51J$dA6yIv*?G6=@uIQT!6KnQe|E#x;~Lyfs5GE9M2&
z=J@*BHchNv{2ZuB`~~;0NT&O53I60Z3H!}bfo0p3>FhI6aOCV&+L!VRYOK64s<Nd<
zy2oIT&lu$Er?PJk3nAn&mzR-`WtH!u@LN-NZ0IH=`1#-oD6U+Bzc0yU_Pq75^Y&!?
z`THa4u;v3;4;@C%TNg67BzgQ`zY`9BHkEn3QNm|+?Qy}AJl0U9%x9caDO+SY6W+O;
zYMfhx-K0*lhTRMnZt%rBc!WK8y9&>2P{TR}7udh^wYW*t81D@2VXq|e@w1s3=;6;N
zEbio9TrPec0*<%}zP>qt+ftjsJ2h0`E3^W9g#OaP1Db-rp1Y{zxAB6v(msN=JkE{q
zQ&cc<N4(%p({8+fPYpG9TO+99{BS}Mx9=qId4hI}5^Vp#fr?D~#-ifJu!a0pXd2U?
zX(bZYrS@%T7Nc~3bu4at@BkfDsbsC+IQZPzJIu&xkwD4e0^eCH6-;Mkz`*KtbjREn
zlGe1ADnFJcr>EM$uS*Wdbwi|;(AV|Ie|#jm+~-HX^Jc=}`IY>Qs#lSzmLL52dKVQf
zsYVeNqNM6bEnn&Q9B3S;0QG+rz-`_G5DSli+O8mopB!1P?YI)9-i@OZg?d19^f;)j
z(jtW~<gwGlEwHZDl>~6SnoT?Xh+X>@F1Kidry4B8ZOb~K$on=Ps*A!mJUBMs&WG6l
z_bKdqVF|8m3C4vrDfmO_cAPeA5Y1`WjuU<V!(ReSpjr7nT$9bk(}r{f5A5a&R4$*S
zm(FAex^!;~JYMnyQq4r5+%_l>{qLmU%FzsgjPnzL#Qp+-`>8~Mc44JJXm5(ZQZ!D`
zqIFZ?72qpqP+lxZvR)w|Rqt6xTM^rGJ&yW1B+&Cel~{GB9#(ny2i&^W<K>qvt@m;G
zu?3$$VD%1H>m@}B)@{!RaP6_()=I_Gt*>7fwU+kswN}2aW3Acn3okHnvaYIBu^yHE
zh}He<t+!ks!f|g4un6~m?psRmf-HG#{Nxr6)|A56xeo9!vBn$5@`-Ebb+T7&JYM@X
zly0@(MHhKW;y*pwBxIE<vpj7<+qga3dvgP(a&QuLTu<oeusf?6aHUU=3NdkYJLc5g
zLdF_z&|`nJ$sGfGymf96Jh7j{zx~r6uRN3r89`e>B<da<e|ZR2o{9zus}opd`$^>6
zf1TGlc>yl4ol5`P*iKZ(|FzQH@DMFSN8qz`7<TJ+#InCP@y&%T@a}yD;L`Po$}KR3
z#$6N8#JAUI@;7lDG<Kd&9zU7I#tg&Bf|vBK$_2JC3o{qtd2FTh6=u7(h1TvFpz$P(
zp($#twfzhY+rEKG{*7W=b)HkKX~H--7u$;l>F$Im_HfjWNe1j>;f|)vp!Wl%cWv3*
z`TMDO@g~;J?Eq3PaxBRLE!MP3j=Jxe%ObWT5+TmH!ya3*ZtKf5{CYBV>6*xt%v8ZF
zP@PTMl7XHNb-?Lvd6cWAN**jB91~Z9Y|gIdjoA3$@)yqFw^+;Sz@KW^qcT7mPTz(f
zR_~#_G8vB5Ny3uf7x0?O2as6bP5=Fl#0&OuyrrGjDZ1^7L&LrC0UZhE_F*#Ce<Xuf
z<n>a-<u)6~$)Rr>Wtq&a4DwJp3wj*yQ<cLr+4)nPdq>@m+C_Y)365esEn_WurKJa?
ze6~VgfCUrEPX>pVbKr9NG-j2V31`Mu!ousRRMC#}P3)hCJq^pz7L|p#;O-=>aMl*D
z`n?kK6$A06>%!RaTt1FhNWq?K-=cAbd$9MwUzoA>5ZGL?z;DJlHjEzU+3^<#p;tfQ
zd2A6qUv&gIdJ2Q#xD7<;!v}CW7t7a9;xg824p_Z@XGR}t*AmThmarva5|ao%PhCd^
zRP03$?X3LEzxrMcd_K-*xlu3B!W=z%L}3B@(kTyCJ(&3$hqA?~XK7Tn6ths-!F=;d
zs87^-7O1qCrI?*Xbu;2=s;44b_|zSRr?t{WDYKdPUopI3vj>WapTq1Qy@v-=mV;}9
zJloWj4Y$d9ED4wI%FEZoLFYXDux=WDz|BM=APami*`ZFozpzIB6PRr=!exU)(Ck_a
z7F#TETfP~VdLx0KY|e#uNBJ-(e;AUsMMKrytLWR>DY#Z|JOu0;M7;@#s6TEg)s(WJ
z!t30aeFh%|M;Xuo-cIJ7F^;u(E~CqkEla1fS(~*FM5Q~kj)fu2d9Mpg%Xr1qxNKTk
z>J2Jd&SQVcc*ft7L%%1;vrI=l>LJeq_x#`Jr>zwAQE|ot2^(>C!DU#axep)t{sP;b
zT!w!JC4%U<=P;7Dhn%4qbYKl)4+PxvK#~Ew>NSV$uiQohVky%YAI=&My`dAWFR<xX
zC$T#c)#(0`c`RaLKB;x|fF$Pt2#TMDE3e96{u4*|5NbnHOGL4CuNZUOvymPecW-{*
zIt942#vdCUcm>f3s^p87EEf8bMl;3AVceOcxIE-4$gFnZ+|cK-$C*VSQys;OpL%0^
z#TxjArU?{lBCzJJcpU8GB<NJq!k6FF;za?Q1ikP2(B)m1u-Lu?!S(N4rtwEUUfR7=
zplfiJ=KkG^WuHwDBrYnUi#=7b%*LfGbR>uF;)&y*aueB{ifrW1&2CSr%>}ztYXB10
z@R_j;-K}K7^Xd%&xy5(r$Aw$@(O(|JEHzEmyIcw8$43)4Aujvf>;*R`z9a=v1N8Nm
zX;|yyQ7W`nm?Wh;;2SeA-5O~_E5o^Gu8K|w*P6;=jJD(QkzHV+5kjxN^TZz;F47}k
z{?JnBf|mB5Wa;HZ8aMYLY~H?+I_l)}E>up#w{|IVuW_VLX1#%ma|f-el_i<Miwc-v
z)kFWqG*kI~A0c&IF4)|@MC<j9s8py1{5yUUNM16CjIN?T>RO>=xjMF98VRDehtWwp
zQGA4RN9vrGCMRkRg2)on^7)oV)URn@dHbmx*m$}gMvh#9Tf5TX_7f56_-8UN@!34^
zecVT*WfNhnQ5}lh>u74;ZD>!t1AESnqkHn!;+H=c!*jI{^nI8<b`&`W)z_Aiu+wt5
zkT(Om<?f)}+<9j9?HRbs<QLU=T>*P)r(vInRrF(PGn8sC#=+AH=$^$%u+3!`_Zn5!
z`GCu4nT$bLfIc<9=YkIrZ!9=^lj<qY!%8MP_{5SZw5<F-w4V3{vuB?rVkVcM{my%6
z9LuEUs)JB>b|%O^Fr&H<g6;?Rz`#g3O*eQ7|1}9?)u(gW(!y-AOI?-rH~gkCd%nUM
zBLZD-73eFq8Q4I_0IU9(#OezWeD7Dmf3~b*rmO-c&V2z9zB)`lnCmZAnqiHNOW60>
z+VuLL?;vm%XDgcw==gpqEdI=j`icf&gFJ8SRc6I*nFoQht1|wXe4N=Id{492PsI+k
zC)oM1(^R$pAeTWt$)=r6C0R`hpl)=Rp*h;@^4L-kc1mVC*)jB(t}vFm&-K*~zorXY
za^d?o8+QKBH~KN44+KkO;bxQ=>zMfpbdx91warK9BdyDzZllJs2WL>bW7lEf<Pmy4
z&yf!P4gwqbPrMt+YE0(5FKp>DqRB5Km_@EOOYQFD>qZo_=*vYkL(YQs7uK_%FLw}2
z@m8uJeuqUkE~8G*|54{zChWR6*AZzrMT1v$Q>8imC|=x+E^wd9s+6qoiHmiJzj+rF
zFNnj)%bI?YISusWV(k9-1g*ZXf!6rE=k>*@(~ir3=#%jeVfUuB>|@XvZGZe6m1PNY
zeY2Cyv9ADfLUwT1v1jzX^=;C0ghEKM33EO<N+<G%p~l~oiMUQ-s~kCZlNXl<Em+L&
z4tq`{I)-VGj3h4LW_==0qp5xY*IBsF<NLMGhF6Pxu*scO)Gpx+?fFj{?>#nT74c#%
zeXunK>skhrF!!0fKZ+Rh{WqiChsD@)d=W;Z)Zn?*ed^yd0wbnH<m=!v>Z8mteKz>h
zk*H4Uvv~@B|IwY63_G)(cYnjX-UIB=%4`<>m3t3ziOlTkG<Gs30G}J0&eqF`vWh&e
zpH#D!zBg#2l3cR0!ZQSd?my*`PusD+q$g^0dck=q+_6=wFtdtyNsolh#EG>%)Gl70
z@l?&Qk5UPF<S{~Hvlijdl?HID#g)@78saH07DD*^ne@N22e7zwE!-GgLvMgBPHiKw
zC+`%EYjnV<`2#$7^&eXrJs02J=L&e$6Lz^#7a!U-?XKA(NdfU!!SSPAY(w)hfrO4K
zG(J8kFzXBz3`hh+dvvAXfNY?k>d^%pIN^z)M8i<<xA`x2kINF&cz$FHw5M4+3uA$n
ze+XQ9JllGc@dXzCBnLMiakJjK%Nm-)&++c~MiHUAFG*90Eq%9NkG5@n1pCI;f(vgv
z{1V*&WkZW#%k4y-h1x|38TkOGc4dLQ@pInFV`1oRnHPNak%a=0c97ty;yn9TJZW!H
z{65nFx6J08M`2}<BQgos9r;XZ?RwGLLt7wx+9>%qwHejt+k^ZgQ(oD<6!dt&mE)^w
zqmL?DP(FPX_)PxBv%AD`daHs!C8!WttjPttTtApMYzRtC^Pwhzj~o_7q0p29G;n7E
z8DFu5EUKAI$|gr4q48fWQ;iZK;G_kTe0CBIgvCL7_#a-Rb{UEokO1>%7-U|kkeWxM
zR_EPadCk`?(UI5t;e4$jI2o8A?tBY-1wJrj(vRT9YOu~ug%ka{U~}sh2-13>?9yv~
zpwl2)xN;A)?WjfR{(&Uw?+hrOf0WNxm8OBMf6$sMYA9;tBQi~^K(fw-Xzh4cq*W&e
zm;TC8_WUO~6PZoK+ON>P{%7fb@2zOUiwO`O^?`@Bs)9%G1yX$V81G2Q0$34fLzm2Z
zLt|u3Xu^yo9H;X>o#}mu9txABM}O24m#mv)XnhA+^&i*8IX1%alXs)Agfe8}B#!nL
zeMO^xDEgRv0;L*9qT*xQ!REmo{=(_zbm*M{teAL>x3=a#>N@lqt(2L7>WLq<de(zl
zWOwi~|0?lvZfL@1n8@9GBY7noPow!Vc4&ok3AN?#r#*k-D9y;HN1uBm1uq90cUqVJ
zSoZ|{_0FPT84n_Ve;iiQ`ikQE{pr7dsZcxX0<Yox5M5Ys2}u?G<kfsXO<y0ehu@vY
z(HqSZRAWyg+8H?$iQZdB(UMF^P_lwGnh)vF$D?4db~Ri@CFFEkBV6o{gTcm2C~~GG
zo^U)9>d)Qh4Jl5*;kLIx>RUF6LzD2jvRe3b(U5GvZHl`K??Oz@0n~a<89#jY8B$7K
zqQUX9*jjA>ic@3hw)-a_d)FQ~F-eC_eK3hGo9jdrgCtmF&urRprHdFoxKArYv|+@1
zHgBrLICe*>0X3%%^SY!aFv-BF{2fm>kq`M<G;HuCLK8etN=*(m-Qt0sR?UQ3-$82b
z<v`-zS(2vJs_b5@25lD@kXydoUhUs5DibA2L-<l`k4-6QZJa>9$L3I-?`P-%>64`K
zKp%B+YozFj7A;F2rU#N2Q61NV^tAY6+U%N5m;NZBNZ}jR>o1_o8mExf&El+pn*kW*
zIMbg}l5AlakNTFS&;^%8*#6rOsr}(Ddj1VJgKv^yk;??sMqH7_R8FOrb~(`_dg{!?
zX*y+(d#LzNH71uP%rZWHp*ng`=p6SPYIE^2-Q<-_O_mw*3Uimx57t0y3;z(w8&8Ra
z@)hdhl0##j9;RK3ztSZZ@zlJDPsdM?XF(py%y`FV8k?xkhV8ykx=5X6)vGX%jTh+`
zw}-S#sF|i$8&cm;Pa4h5sE+u0k-paoRATde+QDVLGqdt&#iup2DrE(TCJzv2qdJoP
zq8@B^7}H4|PpRZRV=$=qqATvHFgecKk?}r?o>??R>%PpPLcgnMg#BlFxpW!5+TBYJ
zM{2M=%1=0V`X{QtON;qUyhgG8ar!EgPqou6sHnqyx^nakJ;K3CjLl*x%7~=Xc5bFJ
z!gaKxVlDUCiL-xK>Zy@=KJ5%uU^kl2(K|D&sHdnGl^4#Z%i6MN`SA$)!AywFf09Gv
zf8M2<qrLP=W+bi3AEGYb#Mq|AQ>pgaw{)yRm0el?j3>PD5REuJh27r%jy%b^Krdh9
z`W$IyG$JII+AdIKL94!z$~6+KwM>W2@>8NJIYNvV1?-NGCj1+{Mx-w^P|;)0VeidB
zh}Bnzer|R!ap_iE9Z(CsUDDX**e2|hQ3|huWpGQMIxc;31UA+RVWnU<j$b(m_ipCA
zW)ISF`E)<LZ-=DywR~gi&{H?@-|vZnaEKQ?R9`6&n))4Ey3Vm4{w`x(`1}mCxEPXS
zMwLu@my%#kWGB;Z{lrS|7UTEB^43Gog{)8WFLOJM!$i|5j%DgkVv9F^Wm??M?qe{<
zEf#$k*HGM=8x0GOrLd$)uh_}|%$d7(A$7X&5)|qbaQu!Jcv9b5yeL~1rr7z>J5v_3
zsp+H4)$1?&<#?GXryQZay*ymj<Beq;PT@T*1$c>gHk@?X#+)bbVDfJinA^Wh{s70_
zdE_02MO7`aaqI}V1<s?>okyvkM+OtP=CfAcZsask4~rkr#U*Wb!P!I^E85q9?q}{S
z@GXHoZ&75+cf~-?Gk_0WR_L=(G?x1nj1Nt(hHsYY&}v-{z2-Nm&^1}slbS^2m;Xh-
zlg}dOwp|d|wHOX;n@WC^#!ykTn<}&(q=#<)Lh7Bh=<`iq+V=V+J@?j(t)KUT2KtKA
zv7vUlY2qamao8UkqlW1%i8n}fw<MITyF=x6Y$4~r#arcMwecjMDAB@@QGQ#&bGqSp
z8egcw4W$lvKxK(Gq)qkWvdZJ}mBZ3l&n5=%dgG1%WG7;u%7yr>geulw(E$_7I-%m&
zqVnfw3cyh{7F&w`1nrV^F#Ym~dfNBV<fGlFHhDT5TsDK2E}PA%5ev}VMTu;Zc`h4!
zF^jF3+st-y^~BTjMFbm{pJKJ|liAsIJ#6f^q+r;kgPEJvFnbYcL8{##ySPhAV3uhm
z$l36T4KJN3sJJynkdd>1&8k?+YF{?8RUXgKp`=v0wceA3UA3l@E($Z>b_sSx+6qq+
zPr@g5xWLrKn)r-v9_|jZ#;RI5xM{^}{CqXX9V$=7r8`WmbIEJ`W%C`pdd@`ak!4@7
zekj5D1>>w8?_a{P{fBUnVi~Skm4MebCE?l!6<A_|IZk^bg%>_Jh}#|Paj}Lxw$r+e
zn<d@xW=T(M-dTvNd}Z;=<MZjWkK<U(YZd0370n{N53$`|cj=v=To!E`%UT}oqxW9~
zu)n5JZ0{Lw_R{w$dlD-lknz3DLVP~3=b=d8(RY>^C-Pb7pU3Rn-Uzm#I+n$pYh%j1
z^=!1GjrLY(392pjG85S?{L-84EU<nhd-2ttDvoYr7ne$~!}2rPqq$F5zMUBpKP1gA
z+eI<`C)w0tt0h}4afRL=aiVU$=V+I77UykT0JlRDS^cczEODL@n-e+?z7Q2=TdfG~
z5~lFDc^XK)H^OQ58njTs5-uMKLn)7T!QO?gcyWvfF5J!sjnn5j#&jzFb)XG=d6`&K
z(;M$wy$G}ULpYV=lr(U>9(M8@?wWTF>;K{Qtq*JP!NE{`*nKWGtQdofUkzyH_C%N~
z?+V?f3-FiON4V}pJRaA(lRInL;>nxdLeJ+#I3am6{xMMwFJEvLmp+xjSyOId<g*B0
zF_L8+Zk%&^N;ZhxctP6+b}-ujQFg8P5I?E6fVJlZ5v%_c=~sG@%I|4|0A4692oexQ
zgEYA0dXIWU>$77$<ME?sYuMJ)RV*-76!$%POAo!j#TLBLz|1L!d3#kdDtQ9l&#-3C
zozJkJ`yYV!(JxeU+iCW`_yUykIj*$zLDu&66U0B@&O*1ovPV%DK{{2B#lQW=8WL8+
zho#fmQ|UZbepnF=JTYWC)vwtP5eXa`5KMcjf>~MOJ9K}XHf?q+<g%70p!3;5IOHJ0
ze%(8QyV3_B|I{LU>FjeXU$_BY+bQ6E%E{Q<RUS5pT&J-mF8FUiCW-#H3F`#};WJYY
za;&xG7@B^-x>@t+iQ|keRyhfi%Q;UY6T$K+Zg|AqmJRm)Vso}FW<9q5u^kH21=hZ~
zZ2FECd~5PqEV$MU%ecPTl?pN3!ksH7(olBe&;>S_?Z&#Bm1$7nW|q@?m)8ECjyrBn
zU~fh%$Z?N27CW|<tt*}d2?3|ERK_d%bFB~?>Rk!8uMV<{Ll(5|R1WP~w1s%;FTku!
zj&;4=i#rYs@hqi*eSH%PL*hEr@5Zlkets|bc%~zbzY;Wo+m*Ks$kSvcJD$zkOXUye
zkD=x%N%YfcA9ytLE*dw#g7l6P<(SdByyHsoG;^su{vLdV&a=y>Q_|&d^^Zzay-1i^
zv?ap5a!u5*^)QUgOQY@5Cg{WXOsMLwqBGBJgsCdSU|g=olCGTP|CL;cpPxc(y;U%>
zTj__>_lL2d%{Sm%V=NwDDuYxP+2aP`ZkT*{DV#PG1!-=6A@g$s6}OgUM-9XA!|6dR
zM_Zb$KSS|(^?S7X;}qZzB;dxA$z*6;G}r}Q#8UV_nDVg{&SkZOZi5#Ud;67&#A)Hd
zgBN&fTuxBk$9cHPC!YjlP9$dU;_%!x8f;ce1;3J&;KLs-qUAm-;b1=>r~a15DEAt?
z8Qg<S&Lz?hBPXG5eHb>+kY-FN7J|*9aQgk7Ai4IpRjcDcY|iz_6ee4Ox>P)tGiXEI
z=TGx?ReNChJFdJV6?2Huq{Fy#gF2q0KMN}dO~D2s0$5ys7*(0*;^B%h-n2EDr0nE;
z7-uZaeoap%?i^pu^SK(1m(#}jk?~mjGY{XI@&znIXJWJI6{uXco>yBOip`1s|0p`s
zc&gqm3=5f(ka?yOq0ppr_F5Vwg;HpcgoIR*q%;W0ERr-3l8_{ogtMP#i;`4Qh9r>&
zl~npS&+mS}`f)y-<LtekweI`6F#1v``)x1)G@iy0PuFXtlV=zWlsAzR(#Ob@aW6pj
z)_pQZs+knu+k$2}#UwayFLPMyDu%qBM2ZXZVbvEW-er(Obi>@>tll0-Yc-_Kw-SlM
z6EiGa&7a{Xy<|<=5Ab~DG@{b<nq7KT1}9a_p*<m2$rFD~^hj2thw4uf^H&mZCv%AA
za{K5Kmq;4D%AfnUVKi6rAeGis$8h5#wYW20&uQJ=liWq~iQK2{<2kJ_9QQzD6?e5%
zj|+FK;>weka(;e4XxXEaT%Nr#*Pm?1y)b^l1#REJ{p13<_Wsx0s#W3K&IPWV)Y2~Q
z#qB`Or)(N0arQbl{ry5NVXqCBP402JgLAor+|``W=^1A>5WtB)bLPB+cesz+R&gQ)
z4X!W#I2Sp{aH-d(a^h3-IMX`hyky<EtU8t}KevEuIyRMSeNxPwC^qH#i-xJ7A)Z^Q
zWWY&Y_(JcTN#M4$%W_+y#JIb#mwT}38ND?=hT3Hqar+M6qQ=&L$jaIr+TRjKA9j|J
z%iUS@;szfI&Syx^&eintYfF0O?*K8{JDt*_a`d<KJL3QLG*uXyN)<C_LCAb5_K4?5
zYIn;Vmp{G_tpk6_=TLqIeAA_7VWl4Rkvs>6@@vUZnF)R8ItiQZOJKRxUeY)z2}^uZ
z@afyt%w01#G)>^xwT@dz{^ew3*#>Bxzh2aJ>JD1H`VUW7cR}Ef3)odLh}OqduqU(>
zl{Sas-!lU|ui-Mj5<8C*!jiH3#S=X8R?K#aN+J5uU+5&QW-I@`599iVaKlYm+q?M}
z&}jK{l&Mj$^;RxH8Ot7Y(EEqUSqHIWO&1OwmAAFuwihEkrEG(2Ol;o^&*GqKGwyrY
zhJA90s5hY+6*G@wXs|BIn0&^8R!Q4s3w+RSUq8=JG_#Gkb_D;<>%;M&WvfmaQR?Fu
z+c8S+wpB(SaG}LG+kZXFZ8t5vg(Bxxob9{9HiEF&VlQP|d26lhF~^(u`jwgOiQ09x
z^!XR`Vf1VRmmRQ8-=Ju_!AsXRraQw{@0X(OY8fNj@v_;r;R<H9FT~Cvb3)Pf*Wn|0
zXYDxDYdVcv5;>+dY6X@)K93vMrNRA2L3rh0B|ci9ib+ao=pcC?uVsIQDXnMl{WKNZ
z>+u!Pa3~Hn6{T$BCYqy~=_0fo_<?GoHCQI~8|rVILGf2R;Odu7nATZ|xBfcg^nW{H
zorI*VT;zE)88Z<p<0jdvlr*A!ZYj3iH@0<6?ZkGyH&D90k@+}_cRg(I#DY3m5~H^g
zowc=a<dpr?Yakh9=Xc;T{}G)3gm&<^$w0lwp<Ih@5c%cZi09txa28)fgzvX5K@0zp
z+|x~_3=d?1iN!ammt!HctGJ=lN+o)2(=U+si$Vvjf|_k3r(wO+L44}1MgmN_p~K-0
z=4Rh#9~t-a?DaCV=bv>-I=zIM?Xuu8QJHgF`-Y5O@Q!yM8go<Z*HicRmiR|gk~=z^
zu+H)>_^~j84lJ33-}cs^qkx|uB&OpP<p9*s9wfe}XQFV2A^ub5Ibmb+U{IwTBzt+M
zVUIbVX;Bx{A8exw4JGiD(-3q0!dohr?E<+Q%u#IVSAOUCmYBa-g1_zhssEKSq4}NJ
zNdHvRlhQMw<H~-#bD@o{|B(U_cKx{7-~yWlsrdW+O?)oD5sLmD$KZ957_c&p$eY+>
zGT&(pcN3$gyaVxJSpe=#h^H-|Ofja=8q0d?X-Ua26!`O<@Ufri<HJQv{Af+sazLLm
zVtPo=4kJ8q>OcBq&uY5f^eKe6U7<0#=gE3K-q|iv=KA{E$o(gCpyQP!_f>d;FxwKa
z{9Y%$ZmL8tKg~v|>Mq*J=Q^G&4nW7CBw9O{@1k)|_;t2B4f;KcEcmz(X#nrrEjmG-
zp1lJ*6CcwZQpPZAuRktWE=x8PeIjfB1fcQ)XL5ep5z(no6FmCgPhnbP3LGDqiY+(N
zAnfL8=4!=ZT=udRr1iX+eu+GMH18y7F&K|C9B#qhh-6}HABB3;W$^xoa!^^sv(~$o
z;PS)QVb-CexP3RzcIwkbM(iZ^%X$!_tQ^=?bqaM7tO<QyEK=G(2aQ|I;Y0K?dVKQ`
z$lT|<UsWQqS5t@sqprXOueWS_QaN0{)dFw5Ke5w>Zo@^5Pi%$GDB(TLI2`Uc&+OQy
zN7akdK~B?x_l)Kf#q8s7V81vK@#oMzvOzottD8(wt!7<t9SQmV3XVQIO04}C(W0U-
zvh+Dnxr)hD?fY#KV03}X4|~vD{&{UeR4VmLWvIgLD@@VVeCi!PpG?@71t&TjDA%qF
zw-ekTV^IS6oE#5dUhE=)K1JlU_<T~Q)JiPQ$k6zjd#uwGWtw3#hC1&a!<dbd1e=^{
zvgTVbRJR|jo!u!-i*D;sn+@~f&|_6{?VSw0cVZ3uu)d5e->yc3h8xJ`*5kx8`!p%h
zSj}cC?jUy>-oU?OEua!{6?~F4klFMO3|?zvdiWd+`Ky9T%}yk1?>@XZPXn!wtrWgG
zI2KZgBf4LD4Oi^>XM;*r)ZbhP>xwR;Z|D>fUX}xUHpOD~z6w(4phjoN*kkP54{W%5
z4Us5v$M?LCvh}YynQC_#ZZ4S!8=l!=vFmYB^O-OLw#ON9->G1;{TOkP(PV#z|Atjb
ziZCn67#)JFuv(<b_X>mXn)5^);o}0+jI#Ne=|ebi?+m}6nL*b)kwP~+InwK;ih^@(
zV6L%Lv}5ucu(Lc33RV}G9~vj1?Z!L!@Fbk~SlAH~@)blM9+AfD{NG+41Meaf;fLEd
zlG^ebHatdF^6h^_;_+mrH|-)RkQ_s0>yCns;R%xIID!0}eOz?Lqf->^RZgz&dM*5P
z(}`LZ?4>Fx9`IXX4b@IRKukk}VSHX6@%WofH1=#3>Tg&~#YZipiq9^HjQymDv!ohv
z>ez*9_bf>EKBRHI`gr^Pab`$c3TAAV!%zH~v)Et?`OEt%+|PJY&$;tSu*nzDBA#^g
z<+;>n(NA!%G^cZp$q?m1ZFF0%NiRz3kzEh0@YAdJu%}}bmASqj|E~4JA7ihRy5j<j
z=sbcpi585C&SAW4-HT>T>v7xREbRJIgQf2-qSo$fkZ*nw-%mzdIG~Cb%%U+M*B$#z
z`Q68YBK$s;?|Ekh<F<dZ$#bhz7<w@Vj3@fhGp_X{&Tb?sTQpLeOX<X_BLnXqTgPc9
zdQvYVHQRaTHM!w4mZZz_4c0~cqQ_DU!EEVUyb*np#%YM4toIN)IBa5cP1j;l<Qk}4
zvyY_R_Q5eR-Hg=YwQTDBFEGY(JW*PEg_U|0fO`!6S$h=FlG5q;du|d~Jv>B35qu`L
z<ucPH;Lqh_zkuoWLFSTbC7n5&e~z6!2z}mHX>t8Gc(+pviz;}AVw)~*UGf3`rrx0E
zevH6WNew(`E~57aUP8@@M?m*0k>Y_t$S>>QOI$n1wSPt6m~j(&5AP;VjO@Yi*;sb5
z#yjTsoL1)4*f)@vpF|SJkA^XS!tkGp4AG7@A{%rHAm5(fLp%LuW9qL$N&6w<-IC2Z
z*o-B)i?m3Af(e{FN?=A;D^t?40jzmf%F$=yc;eL?m@VRY%p0qi->sHlJHiBZ`ie-6
z+D5V{yO<T77pKdAY$UOJJgA*kGAVj9p6Gd8BDwWZtPB+}-rcjI{t!zvAr|su_A}Lu
z{cMB+3s27_&oaxs$t=jufS8xkRBv@GFncBn<r@x>#{mp^UvQh*r0B|fF)iuv*-4_V
zPj#><sE_!LPK5~}oN(Y)E~)q14xSr=Su@32qMUvZ?u-)(<qaP&QPFC(+dd>P#$LCf
z<k=HZ&lw|jR*NrY44R<zwhzp-I5C{Dm}63H>dDiD3qp^BdT`Y_iF!Y>N2~rC81pik
zd@QoTJ+H>%3@bg-HdP4qRpRWW;{D{NrU%<OTtbr4mH2zpXY$~4JIN?sNKZv}lc&di
zlY$FhiPI?=w5$-v_YdtziTFq?-MAXNv!sZ_iyjF1C4;RMaYR3L0#kSEHhc>nAl=UA
z$*z$=HW{2G4SX+4dvX+$_;>`3u4-WVKAeJ2mmU&5A3kHvr;g-TsuHixa<Cg?K^{6v
z(JEPf_6Yhku3$4wlZ^&nT^U+<fzRMR`38Y8ZnRg)l$bB-g9itX!o3OGL`U8M7CjBc
z#?~yD#Ct}nhE>5ot^?d#(ul*#R*@Z9gVDdv6Dh?jti}C%u<5e|{dq})W=xpMmM3M9
zmh(B}hx|R!xpEDn=u;(ln`{LxN{3+<znd%nFalrsvdpzt6)>})8PZ!;!xMEWe3i=J
zOTJ@7Y97L<gGOl0pTPor{6Jh31zSf{lJ>q8Y~*%htSM?D_UqKBzho5jH0x5+r~O3t
z{sVS)`F?WX>jUzrUqEy|Y-0a3O{HI)6sXv2Yw8u&MApxhq(6OEfmo)RD6e-K^R%lQ
z-dJn1Wz1{xGf;w`#r$D*?A*ed*ec@Pt8zHfx(w_>uEO<AUtm~F3MFrC7fqV7pYdM0
znY})(PZ+9TNu#SrQ$hAwU{_rr{^7QCv#d0Fj&!94%lGrU^JqwSjHmmTq*Hz@$Y%;q
z((y|UQS(biY=QG?s`ns*q(o=Hfa*M2)TvKG9`oF<>hW;m_FM425rb921-RgVG7gUU
z4h4M9)~lrgh66P4lF%4TALN2b?G@-ho(c|O9U#8#7N|T7VU*WrGQEGAK)~%LFHTLM
zXLUR<c3-@(=b1c^1O`8!DH6HWW`f2wO;mVT%rqX?g!jK!;qvvt#FUK!za5Eq+rNX<
zS=?oSJC1)vt*pn^V%WVS7elmip+ch=oPPd-9^0|__w5GoSltf2>K8%SbeP-^R>Hw`
zVwm?wjD{Fz;%tf6f{9)^OxT-zu#5JkUe?M~^GF7<+vr5MSea6>@E*bPg7@T^f*q~;
z^orD<RVIIxrqgzxSeoNr1_vLN^B%c9R8PMMM!h&kvY$oJEJhhuOI;`aC+o;<*G!B&
zuZ3=-M}w8ZSu_q<gjo@d5VTbd#e(00@*a7TA}5I&+wOtdol`V-QZ(wN-eT(8GZ_8;
zbawwx3hR49O|ar+ER)f4it$}_S`_@z1m+CZFmL&c+<A31^qaN^F54`DK!F7Aj9&t!
zI!(fwQ?|^|<?|xPyXkbQw=9<?UPOC-Dso}s$(+uG@!SLQfd;+Zz^S;(alI;sXw^4K
zuJcMEO*<)1<K6dB8%af4`)~y*SL$Zn<&o_c)w7$;92oOAQL{d**Cz9xEMi<OLj<Ld
zz1d9vD&~G+7-P3@ZLLLcCR4b-O8C}k1nbu5E|fhG$9{-#VOE=HGgeh5>~#AH%<IkK
zOy^!1#z{Ar_3b&tjFI{&Y8yHyG@SB{aenU3%vJB;dyu;z{YRcKS9=ZfpMxf_U&k^Z
zt&EtB7qnq+;*jXHVmkAbf41??&a!bC)4){Sc))~wHxcaKb%q(wv%PQUu4X=rOkkpx
zhO?Fd??kD#LxNA^w3&b<{UWJ|eQeuA3n<;?%IN==AopnoTXg;?bF8m@)}`M)%!<R)
zm`HDR)+@q_dA~20xp{+SD^L20vcJz|E_1eQ(ZkUq%hBo#^FW5p)f8j?&@kpWHj8S+
z!<hX&lSCye#M!3AxlH5vTTFvu5bIYTA}YIkUufcIBxFwY)qZ8#gjya~gnwmP8RNC(
z%+qW6qBF<ynVG>SnO>b9VM4wf#H`b1n!+rZ%0urN&v`AvkjaIt%(A)cl>>%sx?3>2
zYN-V~9HYy=J)F+op1PVHn<B>C&ah)ERE&k&miRE8m)lu-uZ}G+*ef)8<H~0D>as7t
zi81H)ZDs9j4B1TmYqen$WklAi2$Lmf6z0FMuRUxg6nafhWput3h^FOkW?WWT3S+cm
zScAoGg5XuRL>1y!MAQ9uu>pU6h=x>digIh-2(M>95z2R{vnJ#S^IKhp5sdsUSQ*q`
z`|W6gaINz$;VeHfrf1xBVa&IO%q~*~0)31awTN}hPQyw@XS^*tyt7Mi_1acp*3Ufl
zYHXdb-K&-Hj|r=-h%jNAREwDj(+h-CwtBOVhi?c=`@aeWZ8O+{9dp>ZO+44QO2B-N
zoXUJ(+QQD9KZ|WGmSJqpm)Gd`cCfn^jw13a!dT}rCpJeShaG62$Z8G>g>6^H!Uc&v
zLWy~bq7^yC%sTfiY*+qtW|7MVc2Rdeo3=h)xWsTjJ0O2fw9WCo(AsecTU57&^=w(l
zIGsut365M8E!Z=KoqQ;lb@{u7+2C@AJ<M}Uc8Tv5`F^kxZZ?l+<U~gV1qZGRyZ*K_
zyY0sEkppW+cJVgm!qvM%|Hf}ZzgNgEcv~S13h5JMX{4~~m+uO+$0yeg`Ck-edOi_d
zez8KRBz{@gG^%e_nc_lLYp)i8ooVc;?F(wtWp&8OKS%hUM2_&kvIO?VqI}WYb-lu|
zb(h)cMs0%Y?&Zv+NmRJYjfgs@{u5fqUlEGFNwf5pJtOb6tk&gOR;{nVR4~`>k|1a1
zG2xXlE7%Qn-NIQdiM&hrrD)#!3RY*@e0JK0ccTAB){5%>i)Xj}tq=&x#h7iaLn5Ep
zG|^Al3!*jCd`0%_cZ>Qiy0atOj)+R`Z5A5E5XMD6U3ArbG+WuVik&8Dz$!Ufu?Ow!
z*?H5;YF)Zq*=cp2OwWfwk(d2N(e2i+!d-n?wPZpgJ7bqL+wjp^Xkb;$8ctlrTFti<
z8sGP3)%KdRQr{wKjZPe9J%@)x@^3aWeB7eeG=4m*{71mdtUM+PKYX4Ek4_QV_+6-(
zo1g|i9^DYNsixQdXY_#4bx0TLKI#+r<-A~e>iU@QmKCgBn-aXP+{`@Zc>v|p%2~^e
ztC;?T^&)oB6rsV#D8@d!Uu1r+RxnsQkKN%Q%RZ~tXPoY*347HjtMm0AyI{*3k$$ZX
zyFBSEyD}tNlyA31wAgnRtC21#j7k)W#N#iEI(JWIhoY#+Ay$KTZ?m;K6&5ms9kIgW
z6D>sPiwc-4-*ng#J$-hXYKb6j`%m`!P6sw{x&|vI)@j2Yw-v3vsmfNIZeZ?jXP9E)
zGR8)yO301Tf|3zqg@w%_qReg5f+m9)o^@QoTFg&?EHib`Iphk@c@OtWlU@jzDFVH~
zhpe_<Al~Rv#cQiBvK3#;&|!H71e(pDCr>NdzKs;HW>)v8!X^V-`7Qe?tEI~crfA#l
zn9)yP>~`grBq-ZX6Est^XeVw{;wL<ydy>ACnaC~r-HHXBhpD%v47X)%298LoqF0<{
zxZt&Guqd#VUMkY%`bX&FlfIjDeeh^5H+l!Ej;x{{a-Zp^4Rf$Xx`=YJE9p+>Vc0F6
zK^@nvr>D*JfV*&jW*3jADWg~7aiy7bocRrye>MRvW$dWpCs{W2Tn1j&bR_HUW`Hs`
z2PZ9GO_v(ZBzNAaVA0(G+U@$4^p=I9`IIE8xQ5@`Y_!L-PwQwzz7sWd(ZQap&*+=z
zE3{a9B;KxkLe0;sa>jYvpnJ=I^kBa^H*IPf_PFq!wYwv^6BemhYF<bkdOy<4)uwp%
zcpZ(C?4xD3E@9RyUlPOS(_c$-P*>TD9#bu%i^*ENsI5VjOPy)>>O|a{S3|@tzw()a
zG`tXMOjoGt(pdrJASf9@Kl%0%Etl0OG1Z)`>pahB6zxI(&!r^B&6)~oSK!m|KSVUR
zjUJAY!NeXrnlmnwdYK{~&Tb|NV-C<+@{X7?w1&(H;~l04c^07RXtH$QIC?7I6&>HL
zCXzO;Y)6wJ%8p-7n&a-W9pom!{hdri?k%CH-Vts2S%A^~1>{tTFG`y)CeCm7vyxfy
zXq>M>Z>4#X2mY}bQIkf_#SN3veGJNGXwyZf45&Uk1Xeu%G~kaReM1y*uFMNEVe=94
zUxPY4jqf7^?H7r3`AF0}636`K-45aJmf@d$2_&j*1~Wx#3B2hqB3T~)*eB~(g2u9E
zB*v#5Za>b1l4bwcC0SPJ6SSQ92w6m1`8G`GNnzA|=21n%UQ%&#1d3aCFzfGS5`on+
z%$$-9g<g-D`ht8AoOI%6c53kOemHz>Plk_8Q-OW`3(Sv{!;E{m%$spzfYmo7vo7&Y
zsWoYkkvf$uO~1k@&TnKsxg20yF5AM{IX3KnVIgqtK{4ZTAQYsJMX{-gnb5P!80vEh
zSiPm0qWMqH@;A!MMC|xG_VPMyD6&3G6u9xEZ)_LOmC_=?se0u3cs=1^g~uen@gZr^
ze?s2Q(x&4*Z;;dzQRL1|S-PXzjum@sHPbC6lr(KzD~x>QhzgS_So(6zBYkOn_IoLq
zq(*_s{joS4>P^m$Jqq1*Kfp~Vi{U&Hn472dF(Aj8D4A>_J=sw(I69KKShR%n{Fwop
zJ}Q8+{ZyiNSA%i6_>qv|8$|Y>23vmJg&Z(&V;3J=K-PSACZ!i+MK#T{h=QXoRXEzu
z&bw78VpOKk-cy;RtHFo0Z}~#bE|-MJ*>53iQVkR)eqv7W*$sJqcg9`O=K20r5PI5x
z3~#$74BtNm^#9Ew%7@o5!<oO~@!gZKw73DPevHES$=6{^#19Y~)&<k59HOBmP1?pT
zfKNB#;q7@B#?2^{)Q0=ON0nM=(^Ch#$|It94+~i4u$de^_=y$U{I_;!yb*~Q^kv*M
zn;6`8hinf!3aJv7V8n!wsuwR|TfHQT=}WNpXMcfPZ3gIU|BJafkj_Yc4}-yDA%K(k
z>*IwmU^}kDo2sp3Pt_1J2MtlwAO(5*x}lMjgVDwy@QCP#g)=^ZNpdk<*yW0k67pEn
z55Z)wqAM&5*~~Uc)DjzG1CqPH6^wlz62q+$wC%Gd`{c4d^&NLxC>)hcwwAx<zwb$8
zO0*`O75|FtI<tWcD~+LR1}4$R)0M!{!k<l23MH{q5}A#UGl};8GIH@(FWa!9f*g)6
zAx)NV$kmJQnIDH{lgl+3qHlAjpsai_`}6?e*$!(lGglm|GlK-WkCd3&$i3k2n#TM*
z7{WWg;~=<05-$cDLZiDROkG$8f(<8yRU-jrpUi{cw=U3`aF2O!XAC!^li;z~SZ3pj
z*-#sh#z<KkfmMMb?<`D(k*3Np=Ib`-;up+jD@WnsJZW%#7$eG=d<}fK45oGL3t|-c
z6(pjiG5Dwpjcpo-$5OS>kI%BXZJUahs`SvaK!%z<cf^s7?wIu_jy6u<JI6^@=sP}|
zez3I0;mvtiq0mOZ8yCRzSxfQ7XpWAEy$a`cI-|Lc80Y)>CkWF5aq5HLG{ov0Yar=>
z{|VH%$Md3L)&sr=bz6p8F~Sy`sx)z0jwGjHJQn*5qH)5@shpzS0<c(^i1fl_PIuW3
zFpb`g_a87^Msqh4ZafXYjWOkV*L;Jze_m+Ytj78C4BcR@bmUTWxjWLb==t9kY(2D;
z({!waPj2=&9JZXxF`Eoxf&-Y@XwPkqNM`473$go%6W3^#L%JR~;p`hTxffS{u)8Lu
zqL_vS7cH5?&h$Qr?K7-69jePT$Jn5dICIY$(n#&9Pz>x@%Jr45BPS}tvA!R;M{Dbu
z@Jmtn<6tP4^T3*C(<|Z6$;sS9nd78-n*f)8h~jp2Cy^%$=3-q!G&gj(nJl<J9{&@M
z<t%5Z(hR@tJeSCe%P9Ou!n$O^WJM@<T6HO9<a*&|Wh@tx=0-=qPX$eteVl%JB7I$u
zB2;_j$!+e4q4PaUp!~&H?%b#mH0<A3xb#Yk3n)24y7!vm$%a{+*}Z)7v12Jt8)eDm
z^0Px9x#gI9LYuR*x&oo&oKY%Tp9`_sAX3zH!ZkZbaG&$0Lgx-Woc!%4jq-Pga<5s~
z*D*l5PkS&$eCKe6ehGz#GI;euK1z1?&=&)98Hh2*%ZaaP$?0jVd`~^}<PXsK$?EWN
z<0oj`bcP-~FoKD5e+G9SEujWSUW+uQuMig8-cN_WCX>|sQ;c!{B08-xlr7rm&K#kS
z$j<siMo^b6%IUsNy#3Vifml8JdX^cDduD=R`MfURs28oe-3e_^<xqXC8J)Xe1%479
zMRK3-x5@fJ&V+dwZ#bSh-d%u0s?%_InD=|`n~hDITv12T3H;}W;lZr|*#2cHSjCy*
z8TVLpn-E1NWPF3p=ZCR;S{Ixs{{x?0%JK1$>5$&)gyTKZv15@Ye7v>|V}9jfv%_mP
z^VB@lyO)L|#45?aBTJM_9glVqQ|OG&30Qq^8pcf>&tz7w!<LJ7IJjjsu~d-5oOnAF
z7^aZdkHfLmEDAqO^`w%=lyT!54L-jhM_ue5!biU%nEP0PdNgTcegx0lo-vN9u2}-r
zQvaZ{?l_s(n+*L5Zurtrp1Mj;#{Dm&a1Woa`@6jX3=Ser*AyqsR;8fOzYV);U$Vz%
zn!|UeXCT(^M7y4T0*{!L;5W*VUSB#7^sdRHL2eJpdyohVRqw&UC@b3Px?EtOB7;ps
zvuM?l#c+t_XH>&WnWdUPp}jQ|d>_b?S4j<g=G_usAIlMi%`XE}yFz&9G@Ym!2(ah?
z!w!hPLd>uOhKqH8ba@&yySU)U90nzyTo;Z0DT&+NwQxg?1_+iugUPNF@$vz6H1W)Y
z<%1mDv9E`N3c0X#vJ8HF*ax2qN8r4I(O8i2gOLc2gMyCb$QCZDZ9SlgH!jb`z*ka?
z+RX*nuc3<0Vd{);w*-{Ct;Qo|&7@9)V{7Fr;YZFEQPZxUjMt~_%pLE|jQ!*|h&-wU
zexv7!yggLNck!<xKkF?1e(ow#y57s|xirX@X*RIfx0byg+C=`Xm&Dty(l}@xN#(gS
zFnmCOhfXI_kK(s{7cc_bl~&N%do$tuQ$DLw+(cJi?1uhL2l1BdAzGj{ig!*YpzZ@3
z`iY$nHjiTQ`PLX}shZ8`l^#I3dm5lH{s=i3<VPOO&*mNRF%a^x0(2$#ob9NoP^frN
z;Qjr0?flYuXd0A&){JWCV(-Ap93L`DHxpbW+%S0bG^Xp57ACYBVD;R0WZl3FyqftE
z0(OT}AM<ETSMx@D`*hl1b^=E=X@YaDJa^pZEY9oyKptf4a~@aE;jd>6By%mp9U5AS
z+MP!9a5QkUf1ZUk)hDUvL?=$Wse&*aqdBh9feX~PrQy1bRC>PwS5lflP1PFdvn&-Z
z;0ND@kv&ce#ZFO&y=$o4k2mZ*_5a9CJ9+BhI|GkA8iD%)2Z{2=O#G7IfxXSn^rXBW
zp3pQx&k_}qbG``^3r?V7cQU)<^LiBa%thxfr$9mb2u7AVVE3_Kpj~N)l20wMXA+;I
zzc>+Rwh?&IqK|T;{qbC7H&}gaVphT!jC%gNI!w|Kj``n#jjL5i)0<O*^u=F6rOTQf
z3YBKp%h|x`4t=_ZlV!X3v%!qLqv$E$G)Uj0fUg%;6P@S7;LK-vlX4_!`0ab_6n7QI
zZR#ANZ7qT>)#-RbrI4xj>jwWb!yxnZFnM8rmO179o|*BMp%0d6VmJS}WE+mA`<Ojg
zmS&3=N~LIVx+%H@^4HW@WxCZ@5#usv;}Ypn)bmUyxEP0ElU)V*t&#`{A1tt>eH|6G
zwt%|vD*WDPOr;{<1J=6Xk{)ro=x`!5IrM?%=L{;p${A+Z=YV5LA=R<H#JgweAb>kW
ze;Dw;|JWEGAFZPH2}dyg=4pI-HHqGzorG4dkr)-Xi+Y#GV(`IGTtVt-&HZiY9LeD3
zyu;L@!w%cj+|lkq8jV_SilRDA)ERM+&f+HGoTx)k@@|m+J?M&ISF+)Z;(glo+7K79
zBIw)MPZwX5#%1wiAYZnZw(rux?&Kd3E0aod-x}iiw5d3}V?X`*d@;y({(uQHn(4h_
zd0Z909f#}J(@UerVEgwaDC@R@#<7iH>M;$Qr*5Iv=DYB$%MNgHE#UdXS=c>(GHUZQ
z<>(19xamm&(0g;Jysi<ZUy{V29Vh5apKZ9<aU3pATSV2I<FV>>1XgcXB064tzxVAG
zoL#5@QQd)PZg>pqtOr@el5&*#cM{`tBiOkmyK#7{H2+#2<Z#kRw2!_fy1Ju>ytulV
zS-o!}=~~iBlH~qlj-T|RSzn5YLXZ@>6}XQMY&4`k|JE{IQc<)cwvbl-R>xMw@w9Pg
z6&>R%gJ%piA?Bho-81<otY1CEOy5__uIY*AIqM>9FL%Po<LA-l?QP7^;6Ixe4rmc*
zj3#gzv<%#E|J(Cqyh;Jp*^mMrC%kAyeG#>*oQPw`+tFTSE&5c=0_46fr7kDhh;Iqs
zrFy@T9^2<kqUs}YU*Q5WBY8bsA4_rP>V-JPeI$Nf+lXep6L6vTbX3MRoSvMAZ>;@r
z-k2(+ayoc+_Y#nAkHukBMCHF)%=p!7v2{Tx#4oj{%cJ(=4_R}vc-m3wJtiA>^{7*)
z&Av2LDi@0^d&!8;V)T)^FZ$j;OzpgCXjtYV@NU=ThG*Mz3Db^|{dG3nvEQLw0oYK>
zBg?tZ&PiO}i%E2OZxpvNC!0&V{D=rD+&I&;Bb?FC-{k$MNnEVWZtmQ%3yi^~8QlB#
zf!rNo9@$=F%{|IGz&);`WRv<7uI2R}F8|*T*57z7=QAad8{;xY<fy)wi_kd8wH54w
z&l8<FCnkwYGPc5R4pTTwRab7K{|H-qy9;b#xCy=d!@zdP`6<NZJO_neA93vZ?QGMl
zCZSS!K7MnbL(89L&=2otgX>jYF5G~>?nRW*NTu^!pvMue^r0jd`{oUItZazeooB$E
zohMg^L;7`=A70W0z9Z^f@@CX+wQ-_Tci-kbkE_-#y~BHkj?Lpz{M$I0=|;8-pDqSz
z-i28eJ%J=QD8s;nA))#kIdZHz1||gcGe`42v(F;`FvnKk7TyWx$Sy+{_+=HvMvLZA
z|6^A0-r+HuV3bS)^?06acO*M+8l{;RW5MJ28j{Gf<a^xD6V;BzRAcrp8nN{&S-#ML
zHp!0So|~FcKS3A`|MH0{j5ne|r|f9|RzjT$CCMn&nM8e403A^?54eWE!qKi9sY};I
zCU-)N(77~)9_*@TeCGKHlhR|TOy+XdfM;ZtuH8T_!Z#9=jmmU#ZzMgjrHi#_FrW|0
z;_2kGdSqzNU()n`0u_6*jYkgdCL;ykh|HSL?56+f$XNR!B9=M|jD|dk#Hh*qoXL^o
zJYva&r>m%n&p{G#zlAJYyO=Kj&ztzYwk0{bdi3{!{laZqd`a;AJH-2=8kw(koLqVK
zk<6$nC58D-WY>3Dnz?g4Ij}Q<<gPHKIS*oq$69&1a^DnsDd`E(`>jr0#t#rJtp<J-
zI7I5@_?@ZO=2~`U6*;E;kG&Igl`)QqCKDF~GxZbZ5b3f~vU;ZqWIbyU4tC43$NcWk
zsw`_{%9Qwh(&kY_(f^*H_@pGc9+6J!iVZ}wO;gy|6~(NZHJ=Shxy3#jFkv-<r$b@3
zyx_uv3})>I1$bq1gqgHR9ZsmtgT0+8j8o+XGCt|HaFkCLb9TKsN%ka6`owBc(3hj^
zlmBvI-oO!2!&G&0^3X72;&ztNd7(<W_Z5QJ1Ye=pa1q%(eGORu7zdL@(@9d|QmE-3
z37d=J$>Ozd8ODueCN-ZV!zNFdCFhqg&8|<`^E%}`-@-yvZgZaPb{5Ayh5qbzp^(j(
z>B$%e8nEpeH`(SPDKOGL#riZT6X%0A;H_^8!LMUjxoAc3r*q+9TP=IDAb{OtJ`(H<
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
z%0D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%0ApD
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
LlWz^rKXT;%XW`(G

diff --git a/backend/server.ts b/backend/server.ts
index 21726fa..15e84d2 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -78,7 +78,7 @@ try {
   if (telemetryApiKey) {
     telemetry.init({
       apiKey: telemetryApiKey,
-      appName: 'Aprendemo',
+      appName: 'Inworld Language Tutor',
       appVersion: '1.0.0',
     });
 
@@ -334,7 +334,7 @@ app.post('/api/export-anki', async (req, res) => {
       return;
     }
 
-    const defaultDeckName = `Aprendemo ${languageCode || 'Language'} Cards`;
+    const defaultDeckName = `Inworld Language Tutor ${languageCode || 'Language'} Cards`;
     const apkgBuffer = await exporter.exportFlashcards(
       flashcards,
       deckName || defaultDeckName
diff --git a/frontend/index.html b/frontend/index.html
index edf10b7..09d608f 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -2,12 +2,12 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Roboto+Serif:ital,opsz,wght@0,8..144,100..900;1,8..144,100..900&display=swap" rel="stylesheet">
-    <title>Aprendemo</title>
+    <title>Inworld Language Tutor</title>
   </head>
   <body>
     <div id="root"></div>
diff --git a/frontend/public/favicon.svg b/frontend/public/favicon.svg
new file mode 100644
index 0000000..0de7171
--- /dev/null
+++ b/frontend/public/favicon.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="Layer_3" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 230.16 311.45"><g id="Layer_1"><path d="M56.49,198.32c44.37,29.83,107.02,15.58,140.22-25.02,40.88-49.56,28.68-120.12-14.06-152.37-11.09-7.7-23.21-13.78-36.29-17.26C140.26,1.87,131.77.13,127.87,0c-5.98-.19-3.99,4.73-5.05,5.94s-12.01,1.7.38,6.05c7.33,2.57,2.87,2.72-2.72,7.78-4.95,4.48-.63,9.5-2.34,11.26-7.34,7.56,3.9,10.88,9.7,14.18,28.1,15,43.58,42,38.46,73.79-7.19,42-69.74,60.14-97.42,26.93-21.29-25.18-13.24-67.1,17.07-80.77,4.2-2.03,13.68-4.99,9.61-4.65-15.69,1.31-27.94,9.66-31.9,12.69-.34.26-.79-.14-.58-.51,2.87-5.05,19.5-16.83,52.22-20.97,5.85-1.26-16.16-5.87-42.3-.02-.49.11-.53-.36-.23-.53,9.63-5.63,23.34-6.97,24.36-7.74.92-1.29-6.27-1.22-8.77-1.21-18.19.63-33.9,7.4-46.93,19.7-20.02,17.06-26.58,45.13-23.81,70.37,3.24,26.1,17.58,50.62,38.87,66.04Z"/><path d="M217.54,270.08c-3.73-5.27-5.6-12.46-11.94-15.31-11.43-5.01-23.18-4.48-35.83-6.01-23.81-2.11-49.1-3.66-71.23-3.96-20.65.3-57.13,1.65-75.91,3.32-33.36,2.97-17.83,8.26-18.88,17.62-.38,3.45-4.15,3.17-3.73,6.55.7,4.9,9.89,11.03,14.51,12.27,20.35,5.44-6.65,6.25-3.63,11.69,2.51,4.53,13.71,3.23,18.28,5.03l57.22,2.97c1.78-.02,3.55.24,5.21.41,4.27.13,9.07-.36,13.76.25,10.2.58,20.48,2.87,30.71,3.12,7.05.52,13.78.2,20.98.47,5.43.7,11.88.27,16.75,1,3.04.35,5.83.2,8.88.65,8.07,1.15,16.11,1.32,24.28,1.21,3.11.1,6.3.16,9.4-.04,3.31-.19,6.92-.05,9.58-2.17,1.58-.93,1.5-2.82,1.83-4.12.41-.71,1.27-1.09,1.65-1.81.42-1.24.69-2.53.71-3.8v-.08c.09-4.32-1.98-8.57-3.56-12.58-2.63-5.81-5.72-11.24-9.06-16.68Z"/></g></svg>
\ No newline at end of file
diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg
deleted file mode 100644
index e7b8dfb..0000000
--- a/frontend/public/vite.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
index 3659165..2782563 100644
--- a/frontend/src/components/FlashcardsSection.tsx
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -48,7 +48,7 @@ export function FlashcardsSection() {
         },
         body: JSON.stringify({
           flashcards: validFlashcards,
-          deckName: `Aprendemo ${languageName} Cards`,
+          deckName: `Inworld Language Tutor ${languageName} Cards`,
           languageCode: currentLanguage,
         }),
       });
@@ -61,7 +61,7 @@ export function FlashcardsSection() {
       const url = window.URL.createObjectURL(blob);
       const a = document.createElement('a');
       a.href = url;
-      a.download = `aprendemo_${currentLanguage}_cards.apkg`;
+      a.download = `inworld_language_tutor_${currentLanguage}_cards.apkg`;
       document.body.appendChild(a);
       a.click();
       document.body.removeChild(a);
diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index d36e663..f9b6ad9 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -20,7 +20,7 @@ export function Header() {
   return (
     <header className="header">
       <div className="container">
-        <h1 className="logo">Aprendemo</h1>
+        <h1 className="logo">Inworld Language Tutor</h1>
         <div className="header-controls">
           <div className="language-selector">
             <select

From 2c96ccc99e852fdf7d00c3bb8104e7d79e500650 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 30 Dec 2025 23:42:29 -0800
Subject: [PATCH 14/49] made flashcard graph handle multi language better

---
 .gitignore                                    |   1 +
 backend/config/languages.ts                   |   5 +-
 backend/graphs/flashcard-graph.ts             |  45 ++----
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   | 132 +++++++++++++-----
 .../nodes/dialog-prompt-builder-node.ts       |   9 +-
 .../graphs/nodes/interaction-queue-node.ts    |  12 +-
 backend/graphs/nodes/state-update-node.ts     |   1 -
 backend/graphs/nodes/text-input-node.ts       |   5 +-
 .../graphs/nodes/transcript-extractor-node.ts |   1 -
 .../graphs/nodes/tts-request-builder-node.ts  |   1 -
 backend/helpers/anki-exporter.ts              |   6 +-
 backend/helpers/audio-utils.ts                |   5 +-
 backend/helpers/connection-manager.ts         | 107 ++++++++++----
 backend/helpers/flashcard-processor.ts        |   9 +-
 backend/helpers/multimodal-stream-manager.ts  |   6 +-
 backend/helpers/prompt-templates.ts           |  14 +-
 backend/server.ts                             |  10 +-
 frontend/README.md                            |   8 +-
 frontend/eslint.config.js                     |  14 +-
 frontend/public/audio-processor.js            |   7 +-
 frontend/src/components/ChatSection.tsx       |  19 ++-
 frontend/src/components/Flashcard.tsx         |   4 +-
 frontend/src/components/FlashcardsSection.tsx |  22 +--
 .../src/components/TranslationTooltip.tsx     |   3 +-
 frontend/src/context/AppContext.tsx           |  76 +++++++---
 frontend/src/main.tsx                         |  10 +-
 frontend/src/services/Storage.ts              |   5 +-
 frontend/src/services/WebSocketClient.ts      |  20 ++-
 frontend/vite.config.ts                       |   6 +-
 29 files changed, 372 insertions(+), 191 deletions(-)

diff --git a/.gitignore b/.gitignore
index 82386e2..bf5f0e7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -143,3 +143,4 @@ backend/audio/
 .DS_Store
 CLAUDE.md
 templates/
+.claude
diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index efc9e24..58b8892 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -277,9 +277,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
 export function getLanguageConfig(code: string): LanguageConfig {
   const config = SUPPORTED_LANGUAGES[code];
   if (!config) {
-    console.warn(
-      `Language '${code}' not found, falling back to Spanish (es).`
-    );
+    console.warn(`Language '${code}' not found, falling back to Spanish (es).`);
     return SUPPORTED_LANGUAGES['es'];
   }
   return config;
@@ -313,4 +311,3 @@ export function getLanguageOptions(): Array<{
  * Default language code
  */
 export const DEFAULT_LANGUAGE_CODE = 'es';
-
diff --git a/backend/graphs/flashcard-graph.ts b/backend/graphs/flashcard-graph.ts
index b9b87e0..66835ec 100644
--- a/backend/graphs/flashcard-graph.ts
+++ b/backend/graphs/flashcard-graph.ts
@@ -12,11 +12,6 @@ import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { flashcardPromptTemplate } from '../helpers/prompt-templates.js';
 import { v4 } from 'uuid';
 import { Flashcard } from '../helpers/flashcard-processor.js';
-import {
-  LanguageConfig,
-  getLanguageConfig,
-  DEFAULT_LANGUAGE_CODE,
-} from '../config/languages.js';
 
 class FlashcardPromptBuilderNode extends CustomNode {
   async process(
@@ -24,7 +19,9 @@ class FlashcardPromptBuilderNode extends CustomNode {
     input: GraphTypes.Content | Record<string, unknown>
   ) {
     const builder = await PromptBuilder.create(flashcardPromptTemplate);
-    const renderedPrompt = await builder.build(input as Record<string, unknown>);
+    const renderedPrompt = await builder.build(
+      input as Record<string, unknown>
+    );
     return renderedPrompt;
   }
 }
@@ -79,9 +76,9 @@ class FlashcardParserNode extends CustomNode {
 }
 
 /**
- * Creates a flashcard generation graph for a specific language
+ * Creates a flashcard generation graph (language-agnostic)
  */
-function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph {
+function createFlashcardGraph(): Graph {
   const apiKey = process.env.INWORLD_API_KEY;
   if (!apiKey) {
     throw new Error('INWORLD_API_KEY environment variable is required');
@@ -111,7 +108,7 @@ function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph
   const parserNode = new FlashcardParserNode({ id: 'flashcard-parser' });
 
   const executor = new GraphBuilder({
-    id: `flashcard-generation-graph-${languageConfig.code}`,
+    id: 'flashcard-generation-graph',
     enableRemoteConfig: false,
   })
     .addNode(promptBuilderNode)
@@ -128,30 +125,16 @@ function createFlashcardGraphForLanguage(languageConfig: LanguageConfig): Graph
   return executor;
 }
 
-// Cache for language-specific flashcard graphs
-const flashcardGraphCache = new Map<string, Graph>();
+// Cache for the single flashcard graph instance
+let flashcardGraph: Graph | null = null;
 
 /**
- * Get or create a flashcard graph for a specific language
+ * Get or create the flashcard graph (language-agnostic, uses input params for language)
  */
-export function getFlashcardGraph(
-  languageCode: string = DEFAULT_LANGUAGE_CODE
-): Graph {
-  if (!flashcardGraphCache.has(languageCode)) {
-    const languageConfig = getLanguageConfig(languageCode);
-    console.log(
-      `Creating flashcard graph for language: ${languageConfig.name} (${languageCode})`
-    );
-    const graph = createFlashcardGraphForLanguage(languageConfig);
-    flashcardGraphCache.set(languageCode, graph);
+export function getFlashcardGraph(): Graph {
+  if (!flashcardGraph) {
+    console.log('Creating flashcard graph');
+    flashcardGraph = createFlashcardGraph();
   }
-
-  return flashcardGraphCache.get(languageCode)!;
-}
-
-/**
- * Legacy function for backwards compatibility
- */
-export function createFlashcardGraph(): Graph {
-  return getFlashcardGraph(DEFAULT_LANGUAGE_CODE);
+  return flashcardGraph;
 }
diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index fc9be2d..846f1ca 100644
--- a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -63,7 +63,9 @@ class AssemblyAISession {
       isExpired
     ) {
       if (isExpired) {
-        console.log(`[AssemblyAI] Session ${this.sessionId} expired, reconnecting`);
+        console.log(
+          `[AssemblyAI] Session ${this.sessionId} expired, reconnecting`
+        );
       }
       this.closeWebSocket();
       this.initializeWebSocket();
@@ -78,7 +80,9 @@ class AssemblyAISession {
   }
 
   private initializeWebSocket(): void {
-    console.log(`[AssemblyAI] Initializing WebSocket for session ${this.sessionId}`);
+    console.log(
+      `[AssemblyAI] Initializing WebSocket for session ${this.sessionId}`
+    );
 
     this.wsConnectionPromise = new Promise<void>((resolve, reject) => {
       this.ws = new WebSocket(this.url, {
@@ -86,7 +90,9 @@ class AssemblyAISession {
       });
 
       this.ws.on('open', () => {
-        console.log(`[AssemblyAI] WebSocket opened for session ${this.sessionId}`);
+        console.log(
+          `[AssemblyAI] WebSocket opened for session ${this.sessionId}`
+        );
         this.wsReady = true;
         resolve();
       });
@@ -98,7 +104,9 @@ class AssemblyAISession {
           if (message.type === 'Begin') {
             this.assemblySessionId = message.id || message.session_id || '';
             this.sessionExpiresAt = message.expires_at || 0;
-            console.log(`[AssemblyAI] Session began: ${this.assemblySessionId}`);
+            console.log(
+              `[AssemblyAI] Session began: ${this.assemblySessionId}`
+            );
           }
         } catch {
           // Ignore parsing errors
@@ -112,7 +120,9 @@ class AssemblyAISession {
       });
 
       this.ws.on('close', (code: number, reason: Buffer) => {
-        console.log(`[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`);
+        console.log(
+          `[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`
+        );
         this.wsReady = false;
       });
     });
@@ -149,7 +159,9 @@ class AssemblyAISession {
 
   private closeDueToInactivity(): void {
     const inactiveFor = Date.now() - this.lastActivityTime;
-    console.log(`[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`);
+    console.log(
+      `[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`
+    );
     this.shouldStopProcessing = true;
     this.close();
     this.onCleanup(this.sessionId);
@@ -213,14 +225,19 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
   private readonly TURN_COMPLETION_TIMEOUT_MS = 2000;
   private readonly MAX_TRANSCRIPTION_DURATION_MS = 40000;
 
-  constructor(props: { id?: string; config: AssemblyAISTTWebSocketNodeConfig }) {
+  constructor(props: {
+    id?: string;
+    config: AssemblyAISTTWebSocketNodeConfig;
+  }) {
     const { config, ...nodeProps } = props;
 
     if (!config.apiKey) {
       throw new Error('AssemblyAISTTWebSocketNode requires an API key.');
     }
     if (!config.connections) {
-      throw new Error('AssemblyAISTTWebSocketNode requires a connections object.');
+      throw new Error(
+        'AssemblyAISTTWebSocketNode requires a connections object.'
+      );
     }
 
     super({ id: nodeProps.id || 'assembly-ai-stt-ws-node' });
@@ -229,8 +246,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.connections = config.connections;
     this.sampleRate = config.sampleRate || 16000;
     this.formatTurns = config.formatTurns ?? false;
-    this.endOfTurnConfidenceThreshold = config.endOfTurnConfidenceThreshold ?? 0.7;
-    this.minEndOfTurnSilenceWhenConfident = config.minEndOfTurnSilenceWhenConfident ?? 800;
+    this.endOfTurnConfidenceThreshold =
+      config.endOfTurnConfidenceThreshold ?? 0.7;
+    this.minEndOfTurnSilenceWhenConfident =
+      config.minEndOfTurnSilenceWhenConfident ?? 800;
     this.maxTurnSilence = config.maxTurnSilence ?? 3600;
 
     console.log(
@@ -246,8 +265,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       sample_rate: this.sampleRate.toString(),
       encoding: 'pcm_s16le',
       format_turns: this.formatTurns.toString(),
-      end_of_turn_confidence_threshold: this.endOfTurnConfidenceThreshold.toString(),
-      min_end_of_turn_silence_when_confident: this.minEndOfTurnSilenceWhenConfident.toString(),
+      end_of_turn_confidence_threshold:
+        this.endOfTurnConfidenceThreshold.toString(),
+      min_end_of_turn_silence_when_confident:
+        this.minEndOfTurnSilenceWhenConfident.toString(),
       max_turn_silence: this.maxTurnSilence.toString(),
       speech_model: 'universal-streaming-multilingual',
       language_detection: 'true',
@@ -290,7 +311,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     const metadata = input?.getMetadata?.() || {};
     let previousIteration = (metadata.iteration as number) || 0;
 
-    if (!connection.state.interactionId || connection.state.interactionId === '') {
+    if (
+      !connection.state.interactionId ||
+      connection.state.interactionId === ''
+    ) {
       connection.state.interactionId = uuidv4();
     }
 
@@ -306,7 +330,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
 
     const iteration = previousIteration + 1;
-    const baseId = delimiterIndex !== -1 ? currentId.substring(0, delimiterIndex) : currentId;
+    const baseId =
+      delimiterIndex !== -1
+        ? currentId.substring(0, delimiterIndex)
+        : currentId;
     const nextInteractionId = `${baseId}#${iteration}`;
 
     console.log(`[AssemblyAI] Starting transcription [iteration:${iteration}]`);
@@ -370,10 +397,16 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             // Partial transcript
             const textToSend = utterance || transcript;
             if (textToSend) {
-              this.sendPartialTranscript(sessionId, nextInteractionId, textToSend);
+              this.sendPartialTranscript(
+                sessionId,
+                nextInteractionId,
+                textToSend
+              );
 
               if (connection?.onSpeechDetected && !speechDetected) {
-                console.log(`[AssemblyAI] Speech detected [iteration:${iteration}]`);
+                console.log(
+                  `[AssemblyAI] Speech detected [iteration:${iteration}]`
+                );
                 speechDetected = true;
                 connection.onSpeechDetected(nextInteractionId);
               }
@@ -386,12 +419,17 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
           if (connection?.pendingTranscript) {
             // Stitch the pending transcript with the new one
-            finalTranscript = `${connection.pendingTranscript} ${transcript}`.trim();
-            console.log(`[AssemblyAI] Stitched transcript [iteration:${iteration}]: "${finalTranscript.substring(0, 80)}..."`);
+            finalTranscript =
+              `${connection.pendingTranscript} ${transcript}`.trim();
+            console.log(
+              `[AssemblyAI] Stitched transcript [iteration:${iteration}]: "${finalTranscript.substring(0, 80)}..."`
+            );
             // Clear the pending transcript
             connection.pendingTranscript = undefined;
           } else {
-            console.log(`[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`);
+            console.log(
+              `[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
+            );
           }
 
           // Clear interrupt flag for new processing
@@ -403,9 +441,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
           turnDetected = true;
           if (session) session.shouldStopProcessing = true;
           turnResolve(finalTranscript);
-
         } else if (msgType === 'Termination') {
-          console.log(`[AssemblyAI] Session terminated [iteration:${iteration}]`);
+          console.log(
+            `[AssemblyAI] Session terminated [iteration:${iteration}]`
+          );
         }
       } catch (error) {
         console.error(`[AssemblyAI] Error handling message:`, error);
@@ -429,14 +468,18 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             if (session?.shouldStopProcessing) break;
 
             if (maxDurationReached && !transcriptText) {
-              console.warn(`[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`);
+              console.warn(
+                `[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`
+              );
               break;
             }
 
             const result = await multimodalStream.next();
 
             if (result.done) {
-              console.log(`[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`);
+              console.log(
+                `[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`
+              );
               isStreamExhausted = true;
               break;
             }
@@ -447,7 +490,9 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
             // Handle text input
             if (content.text !== undefined && content.text !== null) {
-              console.log(`[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`);
+              console.log(
+                `[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`
+              );
               isTextInput = true;
               textContent = content.text;
               transcriptText = content.text;
@@ -486,12 +531,20 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         audioProcessingPromise.then(() => ({ winner: 'audio' as const })),
       ]);
 
-      if (raceResult.winner === 'audio' && !turnCompleted && !maxDurationReached) {
-        console.log(`[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`);
+      if (
+        raceResult.winner === 'audio' &&
+        !turnCompleted &&
+        !maxDurationReached
+      ) {
+        console.log(
+          `[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`
+        );
 
         // Send silence to keep connection alive - AssemblyAI needs continuous audio
         const silenceIntervalMs = 100;
-        const silenceSamples = Math.floor((silenceIntervalMs / 1000) * this.sampleRate);
+        const silenceSamples = Math.floor(
+          (silenceIntervalMs / 1000) * this.sampleRate
+        );
         const silenceFrame = new Int16Array(silenceSamples);
         const silenceTimer = setInterval(() => {
           if (session && !session.shouldStopProcessing) {
@@ -500,7 +553,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         }, silenceIntervalMs);
 
         const timeoutPromise = new Promise<{ winner: 'timeout' }>((resolve) =>
-          setTimeout(() => resolve({ winner: 'timeout' }), this.TURN_COMPLETION_TIMEOUT_MS)
+          setTimeout(
+            () => resolve({ winner: 'timeout' }),
+            this.TURN_COMPLETION_TIMEOUT_MS
+          )
         );
 
         const waitResult = await Promise.race([
@@ -518,7 +574,9 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
       await audioProcessingPromise.catch(() => {});
 
-      console.log(`[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`);
+      console.log(
+        `[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`
+      );
 
       if (turnDetected) {
         connection.state.interactionId = '';
@@ -549,7 +607,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         text_content: textContent,
       });
     } catch (error) {
-      console.error(`[AssemblyAI] Transcription failed [iteration:${iteration}]:`, error);
+      console.error(
+        `[AssemblyAI] Transcription failed [iteration:${iteration}]:`,
+        error
+      );
 
       const taggedStream = Object.assign(multimodalStream, {
         type: 'MultimodalContent',
@@ -578,7 +639,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     }
   }
 
-  private sendPartialTranscript(sessionId: string, interactionId: string, text: string): void {
+  private sendPartialTranscript(
+    sessionId: string,
+    interactionId: string,
+    text: string
+  ): void {
     const connection = this.connections[sessionId];
     if (!connection?.onPartialTranscript) return;
 
@@ -599,7 +664,9 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
   }
 
   async destroy(): Promise<void> {
-    console.log(`[AssemblyAI] Destroying node: closing ${this.sessions.size} sessions`);
+    console.log(
+      `[AssemblyAI] Destroying node: closing ${this.sessions.size} sessions`
+    );
 
     const promises: Promise<void>[] = [];
     for (const session of this.sessions.values()) {
@@ -610,4 +677,3 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     this.sessions.clear();
   }
 }
-
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index a378b0f..ac4d416 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -52,10 +52,14 @@ export class DialogPromptBuilderNode extends CustomNode {
     const messages = state.messages || [];
     const historyMessages = messages.slice(0, -1); // All except last
     const lastMessage = messages[messages.length - 1];
-    const currentInput = lastMessage?.role === 'user' ? lastMessage.content : '';
+    const currentInput =
+      lastMessage?.role === 'user' ? lastMessage.content : '';
 
     console.log('[DialogPromptBuilder] Language:', langConfig.name);
-    console.log('[DialogPromptBuilder] Messages in history:', historyMessages.length);
+    console.log(
+      '[DialogPromptBuilder] Messages in history:',
+      historyMessages.length
+    );
 
     const templateData = {
       messages: historyMessages.map((m) => ({
@@ -82,4 +86,3 @@ export class DialogPromptBuilderNode extends CustomNode {
     });
   }
 }
-
diff --git a/backend/graphs/nodes/interaction-queue-node.ts b/backend/graphs/nodes/interaction-queue-node.ts
index d6ec1e8..74aa166 100644
--- a/backend/graphs/nodes/interaction-queue-node.ts
+++ b/backend/graphs/nodes/interaction-queue-node.ts
@@ -9,7 +9,12 @@
  */
 
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
-import { ConnectionsMap, InteractionInfo, State, TextInput } from '../../types/index.js';
+import {
+  ConnectionsMap,
+  InteractionInfo,
+  State,
+  TextInput,
+} from '../../types/index.js';
 
 export class InteractionQueueNode extends CustomNode {
   private connections: ConnectionsMap;
@@ -117,9 +122,7 @@ export class InteractionQueueNode extends CustomNode {
 
       // Try to mark as running
       if (dataStore.has(runningKey) || !dataStore.add(runningKey, '')) {
-        console.log(
-          `[InteractionQueue] Interaction ${nextId} already started`
-        );
+        console.log(`[InteractionQueue] Interaction ${nextId} already started`);
         return {
           text: '',
           sessionId: sessionId,
@@ -165,4 +168,3 @@ export class InteractionQueueNode extends CustomNode {
     }
   }
 }
-
diff --git a/backend/graphs/nodes/state-update-node.ts b/backend/graphs/nodes/state-update-node.ts
index ec1ccf6..23f7fed 100644
--- a/backend/graphs/nodes/state-update-node.ts
+++ b/backend/graphs/nodes/state-update-node.ts
@@ -66,4 +66,3 @@ export class StateUpdateNode extends CustomNode {
     return connection.state;
   }
 }
-
diff --git a/backend/graphs/nodes/text-input-node.ts b/backend/graphs/nodes/text-input-node.ts
index c3b550f..6d5fa67 100644
--- a/backend/graphs/nodes/text-input-node.ts
+++ b/backend/graphs/nodes/text-input-node.ts
@@ -42,7 +42,9 @@ export class TextInputNode extends CustomNode {
     }
     const state = connection.state;
     if (!state) {
-      throw Error(`Failed to read state from connection for sessionId:${sessionId}`);
+      throw Error(
+        `Failed to read state from connection for sessionId:${sessionId}`
+      );
     }
 
     // Update interactionId
@@ -59,4 +61,3 @@ export class TextInputNode extends CustomNode {
     return connection.state;
   }
 }
-
diff --git a/backend/graphs/nodes/transcript-extractor-node.ts b/backend/graphs/nodes/transcript-extractor-node.ts
index 6644750..1b47e1c 100644
--- a/backend/graphs/nodes/transcript-extractor-node.ts
+++ b/backend/graphs/nodes/transcript-extractor-node.ts
@@ -49,4 +49,3 @@ export class TranscriptExtractorNode extends CustomNode {
     // No cleanup needed
   }
 }
-
diff --git a/backend/graphs/nodes/tts-request-builder-node.ts b/backend/graphs/nodes/tts-request-builder-node.ts
index 5f40266..df1caa4 100644
--- a/backend/graphs/nodes/tts-request-builder-node.ts
+++ b/backend/graphs/nodes/tts-request-builder-node.ts
@@ -62,4 +62,3 @@ export class TTSRequestBuilderNode extends CustomNode {
     // No cleanup needed
   }
 }
-
diff --git a/backend/helpers/anki-exporter.ts b/backend/helpers/anki-exporter.ts
index 33657b2..4db3e75 100644
--- a/backend/helpers/anki-exporter.ts
+++ b/backend/helpers/anki-exporter.ts
@@ -16,7 +16,8 @@ export class AnkiExporter {
     // Add each flashcard as a card
     flashcards.forEach((flashcard) => {
       // Support both new 'targetWord' and legacy 'spanish' field
-      const targetWord = flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
+      const targetWord =
+        flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
 
       // Skip empty or error flashcards
       if (
@@ -86,7 +87,8 @@ export class AnkiExporter {
    */
   countValidFlashcards(flashcards: Flashcard[]): number {
     return flashcards.filter((flashcard) => {
-      const targetWord = flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
+      const targetWord =
+        flashcard.targetWord || (flashcard as { spanish?: string }).spanish;
       return (
         targetWord &&
         flashcard.english &&
diff --git a/backend/helpers/audio-utils.ts b/backend/helpers/audio-utils.ts
index 6021943..0f0d86e 100644
--- a/backend/helpers/audio-utils.ts
+++ b/backend/helpers/audio-utils.ts
@@ -20,7 +20,9 @@ export function float32ToPCM16(float32Data: Float32Array): Int16Array {
  * This is an optimized version that handles both types to avoid
  * intermediate allocations in the audio pipeline.
  */
-export function audioDataToPCM16(audioData: number[] | Float32Array): Int16Array {
+export function audioDataToPCM16(
+  audioData: number[] | Float32Array
+): Int16Array {
   const pcm16 = new Int16Array(audioData.length);
   for (let i = 0; i < audioData.length; i++) {
     // Clamp to [-1, 1] range and convert to Int16 range [-32768, 32767]
@@ -85,4 +87,3 @@ export function decodeBase64ToFloat32(base64Audio: string): Float32Array {
   // Interpret bytes directly as Float32 (4 bytes per sample)
   return new Float32Array(cleanArray.buffer);
 }
-
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index b54e6b8..5ca5827 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -14,7 +14,11 @@ import { GraphTypes } from '@inworld/runtime/graph';
 import { ConversationGraphWrapper } from '../graphs/conversation-graph.js';
 import { MultimodalStreamManager } from './multimodal-stream-manager.js';
 import { decodeBase64ToFloat32 } from './audio-utils.js';
-import { ConnectionsMap, INPUT_SAMPLE_RATE, TTS_SAMPLE_RATE } from '../types/index.js';
+import {
+  ConnectionsMap,
+  INPUT_SAMPLE_RATE,
+  TTS_SAMPLE_RATE,
+} from '../types/index.js';
 import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
@@ -84,7 +88,9 @@ export class ConnectionManager {
    * Start the long-running graph execution
    */
   async start(): Promise<void> {
-    console.log(`[ConnectionManager] Starting graph for session ${this.sessionId}`);
+    console.log(
+      `[ConnectionManager] Starting graph for session ${this.sessionId}`
+    );
 
     // Create the multimodal stream generator
     const multimodalStream = this.createMultimodalStreamGenerator();
@@ -125,7 +131,9 @@ export class ConnectionManager {
       type: 'MultimodalContent',
     });
 
-    console.log(`[ConnectionManager] Starting graph execution for ${this.sessionId}`);
+    console.log(
+      `[ConnectionManager] Starting graph execution for ${this.sessionId}`
+    );
 
     const { outputStream } = await this.graphWrapper.graph.start(taggedStream, {
       executionId: this.sessionId,
@@ -159,7 +167,9 @@ export class ConnectionManager {
       connection.currentAudioExecutionStream = undefined;
     }
 
-    console.log(`[ConnectionManager] Graph execution completed for ${this.sessionId}`);
+    console.log(
+      `[ConnectionManager] Graph execution completed for ${this.sessionId}`
+    );
   }
 
   /**
@@ -175,13 +185,19 @@ export class ConnectionManager {
     try {
       // Cast to any to work around strict typing issues with processResponse handlers
       // The handlers receive typed data at runtime even though the type system says unknown
-      const resultWithProcess = result as { processResponse: (handlers: Record<string, (data: unknown) => Promise<void> | void>) => Promise<void> };
+      const resultWithProcess = result as {
+        processResponse: (
+          handlers: Record<string, (data: unknown) => Promise<void> | void>
+        ) => Promise<void>;
+      };
       await resultWithProcess.processResponse({
         // Handle string output (transcription from proxy node)
         string: (data: unknown) => {
           transcription = String(data);
           if (transcription.trim()) {
-            console.log(`[ConnectionManager] Transcription: "${transcription}"`);
+            console.log(
+              `[ConnectionManager] Transcription: "${transcription}"`
+            );
             this.sendToClient({
               type: 'transcription',
               text: transcription.trim(),
@@ -193,11 +209,17 @@ export class ConnectionManager {
         // Handle Custom data (transcription from transcript extractor)
         // InteractionInfo has: sessionId, interactionId, text, interactionComplete
         Custom: async (customData: unknown) => {
-          const data = customData as { text?: string; interactionId?: string; interactionComplete?: boolean };
+          const data = customData as {
+            text?: string;
+            interactionId?: string;
+            interactionComplete?: boolean;
+          };
           // Only send final transcriptions (interactionComplete=true) to avoid duplicates
           if (data.text && data.interactionComplete) {
             transcription = data.text;
-            console.log(`[ConnectionManager] Transcription (final): "${transcription}"`);
+            console.log(
+              `[ConnectionManager] Transcription (final): "${transcription}"`
+            );
 
             // Mark start of response processing for utterance stitching
             this.markProcessingStart(transcription);
@@ -223,7 +245,9 @@ export class ConnectionManager {
 
             // Check for interruption (user started speaking again for continuation)
             if (connection.isProcessingInterrupted) {
-              console.log('[ConnectionManager] LLM stream interrupted for utterance continuation');
+              console.log(
+                '[ConnectionManager] LLM stream interrupted for utterance continuation'
+              );
               wasInterrupted = true;
               break;
             }
@@ -253,7 +277,9 @@ export class ConnectionManager {
               });
             }
           } else {
-            console.log('[ConnectionManager] LLM stream interrupted - skipping response complete');
+            console.log(
+              '[ConnectionManager] LLM stream interrupted - skipping response complete'
+            );
           }
         },
 
@@ -269,7 +295,9 @@ export class ConnectionManager {
 
             // Check for interruption (user started speaking again for continuation)
             if (connection.isProcessingInterrupted) {
-              console.log('[ConnectionManager] TTS interrupted for utterance continuation');
+              console.log(
+                '[ConnectionManager] TTS interrupted for utterance continuation'
+              );
               wasInterrupted = true;
               break;
             }
@@ -277,7 +305,9 @@ export class ConnectionManager {
             if (chunk.audio?.data) {
               // Log sample rate on first chunk
               if (isFirstChunk) {
-                console.log(`[ConnectionManager] TTS audio: sampleRate=${chunk.audio.sampleRate || TTS_SAMPLE_RATE}, bytes=${Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A'}`);
+                console.log(
+                  `[ConnectionManager] TTS audio: sampleRate=${chunk.audio.sampleRate || TTS_SAMPLE_RATE}, bytes=${Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A'}`
+                );
               }
 
               // Convert audio to base64 for WebSocket transmission
@@ -320,7 +350,9 @@ export class ConnectionManager {
             // Trigger flashcard generation after TTS completes
             this.triggerFlashcardGeneration();
           } else {
-            console.log('[ConnectionManager] TTS stream interrupted - skipping completion signals');
+            console.log(
+              '[ConnectionManager] TTS stream interrupted - skipping completion signals'
+            );
           }
         },
 
@@ -343,7 +375,10 @@ export class ConnectionManager {
         },
       });
     } catch (error) {
-      console.error('[ConnectionManager] Error processing graph output:', error);
+      console.error(
+        '[ConnectionManager] Error processing graph output:',
+        error
+      );
     }
   }
 
@@ -376,7 +411,9 @@ export class ConnectionManager {
 
     // Check if we're currently processing a response - if so, this is a continuation
     if (this.isProcessingResponse && this.currentTranscript) {
-      console.log(`[ConnectionManager] New speech during processing - interrupting for continuation`);
+      console.log(
+        `[ConnectionManager] New speech during processing - interrupting for continuation`
+      );
       this.interruptForContinuation(this.currentTranscript);
 
       // Send interrupt signal with continuation reason so frontend discards partial response
@@ -424,7 +461,9 @@ export class ConnectionManager {
     if (connection) {
       connection.isProcessingInterrupted = true;
       connection.pendingTranscript = partialTranscript;
-      console.log(`[ConnectionManager] Interrupting for continuation. Stored: "${partialTranscript.substring(0, 50)}..."`);
+      console.log(
+        `[ConnectionManager] Interrupting for continuation. Stored: "${partialTranscript.substring(0, 50)}..."`
+      );
 
       // Remove the last user message and any assistant response that was added
       // before the continuation was detected
@@ -432,17 +471,27 @@ export class ConnectionManager {
       let removedCount = 0;
 
       // Remove the last assistant message if it exists (the interrupted response)
-      if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+      if (
+        messages.length > 0 &&
+        messages[messages.length - 1].role === 'assistant'
+      ) {
         const removed = messages.pop();
         removedCount++;
-        console.log(`[ConnectionManager] Removed interrupted assistant message: "${removed?.content.substring(0, 50)}..."`);
+        console.log(
+          `[ConnectionManager] Removed interrupted assistant message: "${removed?.content.substring(0, 50)}..."`
+        );
       }
 
       // Remove the last user message (the partial utterance that will be stitched)
-      if (messages.length > 0 && messages[messages.length - 1].role === 'user') {
+      if (
+        messages.length > 0 &&
+        messages[messages.length - 1].role === 'user'
+      ) {
         const removed = messages.pop();
         removedCount++;
-        console.log(`[ConnectionManager] Removed partial user message: "${removed?.content.substring(0, 50)}..."`);
+        console.log(
+          `[ConnectionManager] Removed partial user message: "${removed?.content.substring(0, 50)}..."`
+        );
       }
 
       // Notify frontend to update its conversation history
@@ -492,12 +541,16 @@ export class ConnectionManager {
     // These bytes ARE the Float32 PCM data in IEEE 754 format (4 bytes per sample)
     // Simply pass them through as-is, and frontend interprets as Float32Array
     const audioBuffer = Array.isArray(audio.data)
-      ? Buffer.from(audio.data)  // Treat each array element as a byte
-      : Buffer.from(audio.data.buffer, audio.data.byteOffset, audio.data.byteLength);
+      ? Buffer.from(audio.data) // Treat each array element as a byte
+      : Buffer.from(
+          audio.data.buffer,
+          audio.data.byteOffset,
+          audio.data.byteLength
+        );
 
     return {
       base64: audioBuffer.toString('base64'),
-      format: 'float32',  // Frontend will interpret bytes as Float32Array
+      format: 'float32', // Frontend will interpret bytes as Float32Array
     };
   }
 
@@ -545,7 +598,9 @@ export class ConnectionManager {
     this.flashcardCallback = callback;
   }
 
-  getConversationState(): { messages: Array<{ role: string; content: string; timestamp: string }> } {
+  getConversationState(): {
+    messages: Array<{ role: string; content: string; timestamp: string }>;
+  } {
     const connection = this.connections[this.sessionId];
     return {
       messages:
@@ -611,7 +666,9 @@ export class ConnectionManager {
     const trimmedText = text.trim();
     if (!trimmedText) return;
 
-    console.log(`[ConnectionManager] Sending text message: "${trimmedText.substring(0, 50)}..."`);
+    console.log(
+      `[ConnectionManager] Sending text message: "${trimmedText.substring(0, 50)}..."`
+    );
     this.multimodalStreamManager.pushText(trimmedText);
   }
 
diff --git a/backend/helpers/flashcard-processor.ts b/backend/helpers/flashcard-processor.ts
index ef82b3c..4825ff2 100644
--- a/backend/helpers/flashcard-processor.ts
+++ b/backend/helpers/flashcard-processor.ts
@@ -41,7 +41,9 @@ export class FlashcardProcessor {
     if (this.languageCode !== languageCode) {
       this.languageCode = languageCode;
       this.languageConfig = getLanguageConfig(languageCode);
-      console.log(`FlashcardProcessor: Language changed to ${this.languageConfig.name}`);
+      console.log(
+        `FlashcardProcessor: Language changed to ${this.languageConfig.name}`
+      );
     }
   }
 
@@ -57,7 +59,7 @@ export class FlashcardProcessor {
     count: number = 1,
     userContext?: UserContextInterface
   ): Promise<Flashcard[]> {
-    const executor = getFlashcardGraph(this.languageCode);
+    const executor = getFlashcardGraph();
 
     // Generate flashcards in parallel
     const promises: Promise<Flashcard>[] = [];
@@ -126,7 +128,8 @@ export class FlashcardProcessor {
       // Check if this is a duplicate
       const isDuplicate = this.existingFlashcards.some(
         (existing) =>
-          existing.targetWord?.toLowerCase() === flashcard.targetWord?.toLowerCase()
+          existing.targetWord?.toLowerCase() ===
+          flashcard.targetWord?.toLowerCase()
       );
 
       if (isDuplicate) {
diff --git a/backend/helpers/multimodal-stream-manager.ts b/backend/helpers/multimodal-stream-manager.ts
index 5311e8d..4237029 100644
--- a/backend/helpers/multimodal-stream-manager.ts
+++ b/backend/helpers/multimodal-stream-manager.ts
@@ -78,7 +78,10 @@ export class MultimodalStreamManager {
     // Resolve all waiting consumers with done signal
     while (this.waitingResolvers.length > 0) {
       const resolve = this.waitingResolvers.shift()!;
-      resolve({ value: undefined as unknown as GraphTypes.MultimodalContent, done: true });
+      resolve({
+        value: undefined as unknown as GraphTypes.MultimodalContent,
+        done: true,
+      });
     }
   }
 
@@ -135,4 +138,3 @@ export class MultimodalStreamManager {
     return this.queue.length;
   }
 }
-
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index 58d0c61..14d2940 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -20,19 +20,15 @@ export const conversationTemplate = `
 
 # Instructions
 - Greet the user and introduce yourself in {{target_language}}
-- Ask the user if they want a lesson or conversation on a specific topic, then proceed
 - If they don't want anything in particular, lead them in a conversation or lesson about {{example_topics}}, or any other topic which comes to mind
-- You can advise the user that if they want specific flashcards, they should just ask
 {{language_instructions}}
 - Don't always ask the user questions, you can talk about yourself as well. Be natural!
+- As the user is a learner, you can offer them advise and feedback
 
 # Communication Style
-- Vary your conversation starters - don't always begin with greetings or exclamations
-- Respond naturally as if you're in the middle of an ongoing conversation
-- Use varied sentence structures and beginnings
-- Sometimes start with: direct responses, interjections, or simply dive into your response
-- Only use greetings when it's actually the start of a new conversation
-- Be conversational and natural, not overly enthusiastic with every response
+- Use varied sentence structures
+- Generally, be terse, but expound if the user requests it
+- As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
 
 {% if messages and messages|length > 0 %}
 Previous conversation:
@@ -43,7 +39,7 @@ Previous conversation:
 
 User just said: {{ current_input }}
 
-Please respond naturally and clearly in 1-2 sentences. Vary your response style and avoid starting every response with the same greeting or exclamation.`.trim();
+Please respond naturally and clearly in 1 sentence (or two if you have a lot to say).`.trim();
 
 // Note: introductionStatePromptTemplate removed - no longer collecting user info upfront
 
diff --git a/backend/server.ts b/backend/server.ts
index 15e84d2..65d00e1 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -78,7 +78,7 @@ try {
   if (telemetryApiKey) {
     telemetry.init({
       apiKey: telemetryApiKey,
-      appName: 'Inworld Language Tutor',
+      appName: 'inworld-language-tutor',
       appVersion: '1.0.0',
     });
 
@@ -89,7 +89,9 @@ try {
       unit: 'clicks',
     });
   } else {
-    console.warn('[Telemetry] INWORLD_API_KEY not set. Metrics will be disabled.');
+    console.warn(
+      '[Telemetry] INWORLD_API_KEY not set. Metrics will be disabled.'
+    );
   }
 } catch (err) {
   console.error('[Telemetry] Initialization failed:', err);
@@ -405,7 +407,9 @@ async function gracefulShutdown(): Promise<void> {
 
   try {
     // Close all WebSocket connections
-    console.log(`[Server] Closing ${wss.clients.size} WebSocket connections...`);
+    console.log(
+      `[Server] Closing ${wss.clients.size} WebSocket connections...`
+    );
     wss.clients.forEach((ws) => {
       if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
         ws.close();
diff --git a/frontend/README.md b/frontend/README.md
index d2e7761..c987b94 100644
--- a/frontend/README.md
+++ b/frontend/README.md
@@ -40,15 +40,15 @@ export default defineConfig([
       // other options...
     },
   },
-])
+]);
 ```
 
 You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
 
 ```js
 // eslint.config.js
-import reactX from 'eslint-plugin-react-x'
-import reactDom from 'eslint-plugin-react-dom'
+import reactX from 'eslint-plugin-react-x';
+import reactDom from 'eslint-plugin-react-dom';
 
 export default defineConfig([
   globalIgnores(['dist']),
@@ -69,5 +69,5 @@ export default defineConfig([
       // other options...
     },
   },
-])
+]);
 ```
diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js
index 5e6b472..a53e381 100644
--- a/frontend/eslint.config.js
+++ b/frontend/eslint.config.js
@@ -1,9 +1,9 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import reactHooks from 'eslint-plugin-react-hooks'
-import reactRefresh from 'eslint-plugin-react-refresh'
-import tseslint from 'typescript-eslint'
-import { defineConfig, globalIgnores } from 'eslint/config'
+import js from '@eslint/js';
+import globals from 'globals';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import tseslint from 'typescript-eslint';
+import { defineConfig, globalIgnores } from 'eslint/config';
 
 export default defineConfig([
   globalIgnores(['dist']),
@@ -20,4 +20,4 @@ export default defineConfig([
       globals: globals.browser,
     },
   },
-])
+]);
diff --git a/frontend/public/audio-processor.js b/frontend/public/audio-processor.js
index d6fc838..b2f19cf 100644
--- a/frontend/public/audio-processor.js
+++ b/frontend/public/audio-processor.js
@@ -33,7 +33,9 @@ class AudioProcessor extends AudioWorkletProcessor {
     this.inputBuffer = newBuffer;
 
     // Resample to 16kHz
-    const numOutputSamples = Math.floor(this.inputBuffer.length / this.resampleRatio);
+    const numOutputSamples = Math.floor(
+      this.inputBuffer.length / this.resampleRatio
+    );
     if (numOutputSamples === 0) return true;
 
     const resampledData = new Float32Array(numOutputSamples);
@@ -46,7 +48,8 @@ class AudioProcessor extends AudioWorkletProcessor {
       const lowerValue = this.inputBuffer[lowerIndex] || 0;
       const upperValue = this.inputBuffer[upperIndex] || 0;
 
-      resampledData[i] = lowerValue + (upperValue - lowerValue) * interpolationFactor;
+      resampledData[i] =
+        lowerValue + (upperValue - lowerValue) * interpolationFactor;
     }
 
     // Keep unconsumed input samples
diff --git a/frontend/src/components/ChatSection.tsx b/frontend/src/components/ChatSection.tsx
index 6f7afb2..1d62c8c 100644
--- a/frontend/src/components/ChatSection.tsx
+++ b/frontend/src/components/ChatSection.tsx
@@ -1,10 +1,18 @@
-import { useEffect, useRef, useCallback, useState, type FormEvent, type KeyboardEvent } from 'react';
+import {
+  useEffect,
+  useRef,
+  useCallback,
+  useState,
+  type FormEvent,
+  type KeyboardEvent,
+} from 'react';
 import { useApp } from '../context/AppContext';
 import { Message } from './Message';
 import { StreamingMessage } from './StreamingMessage';
 
 export function ChatSection() {
-  const { state, toggleRecording, restartConversation, sendTextMessage } = useApp();
+  const { state, toggleRecording, restartConversation, sendTextMessage } =
+    useApp();
   const [textInput, setTextInput] = useState('');
   const {
     chatHistory,
@@ -52,7 +60,12 @@ export function ChatSection() {
   // Scroll when streaming source content updates
   useEffect(() => {
     scrollToBottomInstant();
-  }, [currentTranscript, pendingTranscription, streamingLLMResponse, scrollToBottomInstant]);
+  }, [
+    currentTranscript,
+    pendingTranscription,
+    streamingLLMResponse,
+    scrollToBottomInstant,
+  ]);
 
   const handleTextSubmit = useCallback(
     (e: FormEvent) => {
diff --git a/frontend/src/components/Flashcard.tsx b/frontend/src/components/Flashcard.tsx
index 459e45c..83888ee 100644
--- a/frontend/src/components/Flashcard.tsx
+++ b/frontend/src/components/Flashcard.tsx
@@ -51,7 +51,9 @@ export function Flashcard({ flashcard, onCardClick }: FlashcardProps) {
           {mnemonic && (
             <div className="flashcard-mnemonic">
               <span className="mnemonic-label">Remember:</span>{' '}
-              <span dangerouslySetInnerHTML={{ __html: escapeHtml(mnemonic) }} />
+              <span
+                dangerouslySetInnerHTML={{ __html: escapeHtml(mnemonic) }}
+              />
             </div>
           )}
         </div>
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
index 2782563..bb6d2fc 100644
--- a/frontend/src/components/FlashcardsSection.tsx
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -107,17 +107,17 @@ export function FlashcardsSection() {
       </div>
       <div className="flashcards-container">
         <div className="flashcards-grid" id="flashcardsGrid">
-        {sortedFlashcards.length === 0 ? (
-          <div className="empty-state"></div>
-        ) : (
-          sortedFlashcards.map((flashcard, index) => (
-            <Flashcard
-              key={`card-${flashcard.targetWord || flashcard.spanish || index}`}
-              flashcard={flashcard}
-              onCardClick={handleCardClick}
-            />
-          ))
-        )}
+          {sortedFlashcards.length === 0 ? (
+            <div className="empty-state"></div>
+          ) : (
+            sortedFlashcards.map((flashcard, index) => (
+              <Flashcard
+                key={`card-${flashcard.targetWord || flashcard.spanish || index}`}
+                flashcard={flashcard}
+                onCardClick={handleCardClick}
+              />
+            ))
+          )}
         </div>
       </div>
     </section>
diff --git a/frontend/src/components/TranslationTooltip.tsx b/frontend/src/components/TranslationTooltip.tsx
index f4c65d1..7270bb5 100644
--- a/frontend/src/components/TranslationTooltip.tsx
+++ b/frontend/src/components/TranslationTooltip.tsx
@@ -17,7 +17,8 @@ export function TranslationTooltip({
   onMouseEnter,
   onMouseLeave,
 }: TranslationTooltipProps) {
-  const { translation, isLoading, translate, clearTranslation } = useTranslator();
+  const { translation, isLoading, translate, clearTranslation } =
+    useTranslator();
   const tooltipRef = useRef<HTMLDivElement>(null);
   const lastTextRef = useRef<string>('');
 
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 4d31b03..1ac1901 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -152,9 +152,7 @@ interface AppProviderProps {
 export function AppProvider({ children }: AppProviderProps) {
   const storageRef = useRef(new Storage());
   const wsClientRef = useRef(
-    new WebSocketClient(
-      `ws://${window.location.hostname}:3000`
-    )
+    new WebSocketClient(`ws://${window.location.hostname}:3000`)
   );
   const audioHandlerRef = useRef(new AudioHandler());
   const audioPlayerRef = useRef(new AudioPlayer());
@@ -172,7 +170,9 @@ export function AppProvider({ children }: AppProviderProps) {
   const pendingLLMResponseRef = useRef<string | null>(null);
   const lastPendingTranscriptionRef = useRef<string | null>(null);
   // Track the last processed pair to prevent duplicate additions
-  const lastProcessedPairRef = useRef<{ user: string; teacher: string } | null>(null);
+  const lastProcessedPairRef = useRef<{ user: string; teacher: string } | null>(
+    null
+  );
 
   // Refs for callbacks to avoid effect dependency issues
   const handleInterruptRef = useRef<() => void>(() => {});
@@ -200,7 +200,10 @@ export function AppProvider({ children }: AppProviderProps) {
         const response = await fetch('/api/languages');
         if (response.ok) {
           const data = await response.json();
-          dispatch({ type: 'SET_AVAILABLE_LANGUAGES', payload: data.languages });
+          dispatch({
+            type: 'SET_AVAILABLE_LANGUAGES',
+            payload: data.languages,
+          });
 
           const isValidLanguage = data.languages.some(
             (lang: Language) => lang.code === state.currentLanguage
@@ -269,7 +272,11 @@ export function AppProvider({ children }: AppProviderProps) {
     if (pendingTranscription && pendingLLMResponse) {
       // Check if we've already processed this exact pair (using ref for synchronous check)
       const lastPair = lastProcessedPairRef.current;
-      if (lastPair && lastPair.user === pendingTranscription && lastPair.teacher === pendingLLMResponse) {
+      if (
+        lastPair &&
+        lastPair.user === pendingTranscription &&
+        lastPair.teacher === pendingLLMResponse
+      ) {
         // Already processed this pair, just clean up
         dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
         pendingLLMResponseRef.current = null;
@@ -282,18 +289,26 @@ export function AppProvider({ children }: AppProviderProps) {
         lastTeacherMessage?.content === pendingLLMResponse;
 
       if (isDuplicate) {
-        lastProcessedPairRef.current = { user: pendingTranscription, teacher: pendingLLMResponse };
+        lastProcessedPairRef.current = {
+          user: pendingTranscription,
+          teacher: pendingLLMResponse,
+        };
         dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
         pendingLLMResponseRef.current = null;
         dispatch({ type: 'RESET_STREAMING_STATE' });
         return;
       }
 
-      const teacherAlreadyAdded = lastTeacherMessage?.content === pendingLLMResponse;
-      const userAlreadyAdded = lastUserMessage?.content === pendingTranscription;
+      const teacherAlreadyAdded =
+        lastTeacherMessage?.content === pendingLLMResponse;
+      const userAlreadyAdded =
+        lastUserMessage?.content === pendingTranscription;
 
       // Mark this pair as processed BEFORE adding (synchronous protection)
-      lastProcessedPairRef.current = { user: pendingTranscription, teacher: pendingLLMResponse };
+      lastProcessedPairRef.current = {
+        user: pendingTranscription,
+        teacher: pendingLLMResponse,
+      };
 
       if (teacherAlreadyAdded && !userAlreadyAdded) {
         storage.addMessage('user', pendingTranscription);
@@ -303,7 +318,10 @@ export function AppProvider({ children }: AppProviderProps) {
         });
 
         const conversationHistory = storage.getConversationHistory();
-        wsClient.send({ type: 'conversation_update', data: conversationHistory });
+        wsClient.send({
+          type: 'conversation_update',
+          data: conversationHistory,
+        });
 
         dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
         pendingLLMResponseRef.current = null;
@@ -384,7 +402,10 @@ export function AppProvider({ children }: AppProviderProps) {
     wsClient.clearAllListeners();
 
     wsClient.on('connection', (status) => {
-      dispatch({ type: 'SET_CONNECTION_STATUS', payload: status as ConnectionStatus });
+      dispatch({
+        type: 'SET_CONNECTION_STATUS',
+        payload: status as ConnectionStatus,
+      });
 
       if (status === 'connected') {
         wsClient.send({
@@ -440,7 +461,7 @@ export function AppProvider({ children }: AppProviderProps) {
 
       // Check if this transcription was already added (e.g., by sendTextMessage)
       const alreadyAdded = lastPendingTranscriptionRef.current === text;
-      
+
       if (!alreadyAdded) {
         // Only set pending transcription for audio-based transcriptions
         dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
@@ -472,7 +493,10 @@ export function AppProvider({ children }: AppProviderProps) {
 
     wsClient.on('llm_response_chunk', (data) => {
       if (!stateRef.current.llmResponseComplete) {
-        dispatch({ type: 'APPEND_LLM_CHUNK', payload: (data as { text: string }).text });
+        dispatch({
+          type: 'APPEND_LLM_CHUNK',
+          payload: (data as { text: string }).text,
+        });
       }
     });
 
@@ -482,7 +506,8 @@ export function AppProvider({ children }: AppProviderProps) {
       dispatch({ type: 'SET_LLM_COMPLETE', payload: true });
 
       const finalText =
-        (data as { text?: string }).text || stateRef.current.streamingLLMResponse;
+        (data as { text?: string }).text ||
+        stateRef.current.streamingLLMResponse;
       dispatch({ type: 'SET_STREAMING_LLM_RESPONSE', payload: finalText });
 
       // Store the LLM response and trigger conversation update
@@ -509,7 +534,9 @@ export function AppProvider({ children }: AppProviderProps) {
 
       if (reason === 'continuation_detected') {
         // User is continuing their utterance - discard partial response silently
-        console.log('[AppContext] Continuation detected - discarding partial response');
+        console.log(
+          '[AppContext] Continuation detected - discarding partial response'
+        );
         audioPlayer.stop();
         // Don't save the partial response - just reset streaming state
         dispatch({ type: 'RESET_STREAMING_STATE' });
@@ -522,8 +549,13 @@ export function AppProvider({ children }: AppProviderProps) {
 
     wsClient.on('conversation_rollback', (data) => {
       // Server removed messages due to utterance continuation - sync frontend state
-      const { messages, removedCount } = data as { messages: Array<{ role: string; content: string }>; removedCount: number };
-      console.log(`[AppContext] Conversation rollback - removed ${removedCount} messages`);
+      const { messages, removedCount } = data as {
+        messages: Array<{ role: string; content: string }>;
+        removedCount: number;
+      };
+      console.log(
+        `[AppContext] Conversation rollback - removed ${removedCount} messages`
+      );
 
       // Convert backend format to frontend format
       const chatHistory = messages.map((m) => ({
@@ -556,7 +588,9 @@ export function AppProvider({ children }: AppProviderProps) {
     });
 
     wsClient.on('language_changed', (data) => {
-      console.log(`Language changed to ${(data as { languageName: string }).languageName}`);
+      console.log(
+        `Language changed to ${(data as { languageName: string }).languageName}`
+      );
     });
 
     // Connect
@@ -619,7 +653,9 @@ export function AppProvider({ children }: AppProviderProps) {
         dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
       } catch (error) {
         console.error('Failed to start streaming:', error);
-        alert('Microphone access denied. Please enable microphone permissions.');
+        alert(
+          'Microphone access denied. Please enable microphone permissions.'
+        );
       }
     } else {
       audioHandler.stopStreaming();
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index 4aff025..3a8bd35 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -1,9 +1,9 @@
-import { StrictMode } from 'react'
-import { createRoot } from 'react-dom/client'
-import App from './App.tsx'
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App.tsx';
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
     <App />
-  </StrictMode>,
-)
+  </StrictMode>
+);
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index 7ac61b1..9a846c9 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -187,7 +187,10 @@ export class Storage {
       languageCode,
     }));
 
-    const updatedFlashcards = [...existingFlashcards, ...flashcardsWithLanguage];
+    const updatedFlashcards = [
+      ...existingFlashcards,
+      ...flashcardsWithLanguage,
+    ];
 
     // Keep only the last 100 flashcards per language
     if (updatedFlashcards.length > 100) {
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index 256ea48..22f5d2a 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -91,7 +91,9 @@ export class WebSocketClient {
         this.ws.onopen = () => {
           // Ignore if this is a stale connection
           if (thisConnectionId !== this.connectionId) {
-            console.log('[WebSocketClient] Ignoring onopen from stale connection');
+            console.log(
+              '[WebSocketClient] Ignoring onopen from stale connection'
+            );
             return;
           }
 
@@ -125,7 +127,9 @@ export class WebSocketClient {
         this.ws.onclose = (event: CloseEvent) => {
           // Ignore if this is a stale connection
           if (thisConnectionId !== this.connectionId) {
-            console.log('[WebSocketClient] Ignoring onclose from stale connection');
+            console.log(
+              '[WebSocketClient] Ignoring onclose from stale connection'
+            );
             return;
           }
 
@@ -148,7 +152,9 @@ export class WebSocketClient {
         this.ws.onerror = (error) => {
           // Ignore if this is a stale connection
           if (thisConnectionId !== this.connectionId) {
-            console.log('[WebSocketClient] Ignoring onerror from stale connection');
+            console.log(
+              '[WebSocketClient] Ignoring onerror from stale connection'
+            );
             return;
           }
 
@@ -166,8 +172,7 @@ export class WebSocketClient {
 
   private scheduleReconnect(): void {
     this.reconnectAttempts++;
-    const delay =
-      this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
 
     console.log(
       `Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
@@ -184,7 +189,10 @@ export class WebSocketClient {
     }, delay);
   }
 
-  private handleMessage(message: { type: string; [key: string]: unknown }): void {
+  private handleMessage(message: {
+    type: string;
+    [key: string]: unknown;
+  }): void {
     switch (message.type) {
       case 'transcript_update':
         this.emit('transcript_update', (message.data as { text: string }).text);
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index d974908..55584f1 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -1,5 +1,5 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
 
 export default defineConfig({
   plugins: [react()],
@@ -12,4 +12,4 @@ export default defineConfig({
       },
     },
   },
-})
+});

From 80da20960334e05fb0a3268d587fae859f16b3b3 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 00:04:29 -0800
Subject: [PATCH 15/49] user response feedback graph and UI

---
 backend/graphs/response-feedback-graph.ts   | 135 ++++++++++++++++++++
 backend/helpers/connection-manager.ts       |  49 ++++++-
 backend/helpers/feedback-processor.ts       |  87 +++++++++++++
 backend/server.ts                           |  50 ++++++++
 frontend/src/components/FeedbackTooltip.tsx |  58 +++++++++
 frontend/src/components/Message.tsx         |  22 +++-
 frontend/src/context/AppContext.tsx         |  19 +++
 frontend/src/services/WebSocketClient.ts    |   7 +
 frontend/src/styles/main.css                | 104 +++++++++++++++
 frontend/src/types/index.ts                 |   8 ++
 10 files changed, 535 insertions(+), 4 deletions(-)
 create mode 100644 backend/graphs/response-feedback-graph.ts
 create mode 100644 backend/helpers/feedback-processor.ts
 create mode 100644 frontend/src/components/FeedbackTooltip.tsx

diff --git a/backend/graphs/response-feedback-graph.ts b/backend/graphs/response-feedback-graph.ts
new file mode 100644
index 0000000..1d486e9
--- /dev/null
+++ b/backend/graphs/response-feedback-graph.ts
@@ -0,0 +1,135 @@
+import 'dotenv/config';
+
+import {
+  GraphBuilder,
+  CustomNode,
+  ProcessContext,
+  RemoteLLMChatNode,
+  Graph,
+} from '@inworld/runtime/graph';
+import { GraphTypes } from '@inworld/runtime/common';
+import { PromptBuilder } from '@inworld/runtime/primitives/llm';
+
+export interface ResponseFeedbackInput {
+  messages: Array<{ role: string; content: string }>;
+  currentTranscript: string;
+  targetLanguage: string;
+}
+
+const responseFeedbackPromptTemplate = `
+You are a {{targetLanguage}} language tutor assistant. Your task is to analyze the student's most recent utterance and provide brief, helpful feedback.
+
+## Conversation so far:
+{% for message in messages %}
+{{ message.role }}: {{ message.content }}
+{% endfor %}
+
+## Student's last utterance:
+{{ currentTranscript }}
+
+## Instructions:
+- If the student made any grammar, vocabulary, or pronunciation errors in their {{targetLanguage}}, offer a gentle correction
+- If the student's response was good, offer a brief word of encouragement or a small tip to improve
+- Keep your feedback to exactly ONE sentence in English
+- Be encouraging and constructive
+
+Your feedback (one sentence in English):`.trim();
+
+class FeedbackPromptBuilderNode extends CustomNode {
+  async process(_context: ProcessContext, input: ResponseFeedbackInput) {
+    const builder = await PromptBuilder.create(responseFeedbackPromptTemplate);
+    const renderedPrompt = await builder.build(
+      input as unknown as Record<string, unknown>
+    );
+    return renderedPrompt;
+  }
+}
+
+class TextToChatRequestNode extends CustomNode {
+  process(_context: ProcessContext, renderedPrompt: string) {
+    return new GraphTypes.LLMChatRequest({
+      messages: [{ role: 'user', content: renderedPrompt }],
+    });
+  }
+}
+
+class FeedbackExtractorNode extends CustomNode {
+  process(_context: ProcessContext, input: GraphTypes.Content) {
+    const content =
+      (input &&
+        typeof input === 'object' &&
+        'content' in input &&
+        (input as { content?: unknown }).content) ||
+      input;
+    const textContent =
+      typeof content === 'string' ? content : JSON.stringify(content);
+
+    // Return just the feedback string, trimmed
+    return textContent.trim();
+  }
+}
+
+/**
+ * Creates a response feedback graph that analyzes user utterances
+ * and provides one-sentence feedback in English
+ */
+function createResponseFeedbackGraph(): Graph {
+  const apiKey = process.env.INWORLD_API_KEY;
+  if (!apiKey) {
+    throw new Error('INWORLD_API_KEY environment variable is required');
+  }
+
+  const promptBuilderNode = new FeedbackPromptBuilderNode({
+    id: 'feedback-prompt-builder',
+  });
+  const textToChatRequestNode = new TextToChatRequestNode({
+    id: 'text-to-chat-request',
+  });
+  const llmNode = new RemoteLLMChatNode({
+    id: 'llm-node',
+    provider: 'openai',
+    modelName: 'gpt-4.1-nano',
+    stream: false,
+    textGenerationConfig: {
+      maxNewTokens: 100,
+      maxPromptLength: 2000,
+      repetitionPenalty: 1,
+      topP: 1,
+      temperature: 0.7,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    },
+  });
+  const extractorNode = new FeedbackExtractorNode({ id: 'feedback-extractor' });
+
+  const executor = new GraphBuilder({
+    id: 'response-feedback-graph',
+    enableRemoteConfig: false,
+  })
+    .addNode(promptBuilderNode)
+    .addNode(textToChatRequestNode)
+    .addNode(llmNode)
+    .addNode(extractorNode)
+    .addEdge(promptBuilderNode, textToChatRequestNode)
+    .addEdge(textToChatRequestNode, llmNode)
+    .addEdge(llmNode, extractorNode)
+    .setStartNode(promptBuilderNode)
+    .setEndNode(extractorNode)
+    .build();
+
+  return executor;
+}
+
+// Cache for the single response feedback graph instance
+let responseFeedbackGraph: Graph | null = null;
+
+/**
+ * Get or create the response feedback graph
+ */
+export function getResponseFeedbackGraph(): Graph {
+  if (!responseFeedbackGraph) {
+    console.log('Creating response feedback graph');
+    responseFeedbackGraph = createResponseFeedbackGraph();
+  }
+  return responseFeedbackGraph;
+}
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index 5ca5827..a6c1905 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -41,6 +41,14 @@ export class ConnectionManager {
     | ((messages: Array<{ role: string; content: string }>) => Promise<void>)
     | null = null;
 
+  // Callback for feedback generation
+  private feedbackCallback:
+    | ((
+        messages: Array<{ role: string; content: string }>,
+        currentTranscript: string
+      ) => Promise<void>)
+    | null = null;
+
   // Processing state tracking for utterance stitching
   private isProcessingResponse: boolean = false;
   private currentTranscript: string = '';
@@ -347,8 +355,9 @@ export class ConnectionManager {
               timestamp: Date.now(),
             });
 
-            // Trigger flashcard generation after TTS completes
+            // Trigger flashcard and feedback generation after TTS completes
             this.triggerFlashcardGeneration();
+            this.triggerFeedbackGeneration();
           } else {
             console.log(
               '[ConnectionManager] TTS stream interrupted - skipping completion signals'
@@ -586,6 +595,35 @@ export class ConnectionManager {
     });
   }
 
+  /**
+   * Trigger feedback generation for the user's last utterance
+   */
+  private triggerFeedbackGeneration(): void {
+    if (!this.feedbackCallback) return;
+
+    const connection = this.connections[this.sessionId];
+    if (!connection) return;
+
+    // Find the last user message
+    const messages = connection.state.messages;
+    const lastUserMessage = [...messages]
+      .reverse()
+      .find((m) => m.role === 'user');
+
+    if (!lastUserMessage) return;
+
+    const recentMessages = messages.slice(-6).map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    this.feedbackCallback(recentMessages, lastUserMessage.content).catch(
+      (error) => {
+        console.error('[ConnectionManager] Feedback generation error:', error);
+      }
+    );
+  }
+
   // ============================================================
   // Public API (compatible with AudioProcessor)
   // ============================================================
@@ -598,6 +636,15 @@ export class ConnectionManager {
     this.flashcardCallback = callback;
   }
 
+  setFeedbackCallback(
+    callback: (
+      messages: Array<{ role: string; content: string }>,
+      currentTranscript: string
+    ) => Promise<void>
+  ): void {
+    this.feedbackCallback = callback;
+  }
+
   getConversationState(): {
     messages: Array<{ role: string; content: string; timestamp: string }>;
   } {
diff --git a/backend/helpers/feedback-processor.ts b/backend/helpers/feedback-processor.ts
new file mode 100644
index 0000000..b322f6e
--- /dev/null
+++ b/backend/helpers/feedback-processor.ts
@@ -0,0 +1,87 @@
+import { v4 } from 'uuid';
+import { GraphTypes } from '@inworld/runtime/common';
+import { UserContextInterface } from '@inworld/runtime/graph';
+import {
+  getResponseFeedbackGraph,
+  ResponseFeedbackInput,
+} from '../graphs/response-feedback-graph.js';
+import {
+  LanguageConfig,
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
+
+export interface ConversationMessage {
+  role: string;
+  content: string;
+}
+
+export class FeedbackProcessor {
+  private languageCode: string = DEFAULT_LANGUAGE_CODE;
+  private languageConfig: LanguageConfig;
+
+  constructor(languageCode: string = DEFAULT_LANGUAGE_CODE) {
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
+  }
+
+  setLanguage(languageCode: string): void {
+    if (this.languageCode !== languageCode) {
+      this.languageCode = languageCode;
+      this.languageConfig = getLanguageConfig(languageCode);
+      console.log(
+        `FeedbackProcessor: Language changed to ${this.languageConfig.name}`
+      );
+    }
+  }
+
+  getLanguageCode(): string {
+    return this.languageCode;
+  }
+
+  async generateFeedback(
+    messages: ConversationMessage[],
+    currentTranscript: string,
+    userContext?: UserContextInterface
+  ): Promise<string> {
+    const executor = getResponseFeedbackGraph();
+
+    try {
+      const input: ResponseFeedbackInput = {
+        messages: messages,
+        currentTranscript: currentTranscript,
+        targetLanguage: this.languageConfig.name,
+      };
+
+      let executionResult;
+      try {
+        const executionContext = {
+          executionId: v4(),
+          userContext: userContext,
+        };
+        executionResult = await executor.start(input, executionContext);
+      } catch (err) {
+        console.warn(
+          'Feedback executor.start with ExecutionContext failed, falling back without context:',
+          err
+        );
+        executionResult = await executor.start(input);
+      }
+
+      let finalData: GraphTypes.Content | null = null;
+      for await (const res of executionResult.outputStream) {
+        finalData = res.data;
+      }
+
+      const feedback = finalData as unknown as string;
+      return feedback || '';
+    } catch (error) {
+      console.error('Error generating feedback:', error);
+      return '';
+    }
+  }
+
+  reset() {
+    // No state to reset for feedback processor
+  }
+}
diff --git a/backend/server.ts b/backend/server.ts
index 65d00e1..a04a635 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -32,6 +32,7 @@ import { ConnectionsMap } from './types/index.js';
 
 // Import existing components (still compatible)
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
+import { FeedbackProcessor } from './helpers/feedback-processor.js';
 import { AnkiExporter } from './helpers/anki-exporter.js';
 import {
   getLanguageConfig,
@@ -61,6 +62,7 @@ let graphWrapper: ConversationGraphWrapper | null = null;
 // Connection managers per WebSocket
 const connectionManagers = new Map<string, ConnectionManager>();
 const flashcardProcessors = new Map<string, FlashcardProcessor>();
+const feedbackProcessors = new Map<string, FeedbackProcessor>();
 const connectionAttributes = new Map<
   string,
   { timezone?: string; userId?: string; languageCode?: string }
@@ -145,9 +147,13 @@ wss.on('connection', async (ws) => {
   // Create flashcard processor
   const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
 
+  // Create feedback processor
+  const feedbackProcessor = new FeedbackProcessor(defaultLanguageCode);
+
   // Store processors
   connectionManagers.set(connectionId, connectionManager);
   flashcardProcessors.set(connectionId, flashcardProcessor);
+  feedbackProcessors.set(connectionId, feedbackProcessor);
   connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
 
   // Set up flashcard generation callback
@@ -189,6 +195,47 @@ wss.on('connection', async (ws) => {
     }
   });
 
+  // Set up feedback generation callback
+  connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
+    if (isShuttingDown) {
+      console.log('[Server] Skipping feedback generation - shutting down');
+      return;
+    }
+
+    try {
+      const attrs = connectionAttributes.get(connectionId) || {};
+      const userAttributes: Record<string, string> = {
+        timezone: attrs.timezone || '',
+      };
+
+      const targetingKey = attrs.userId || connectionId;
+      const userContext = {
+        attributes: userAttributes,
+        targetingKey,
+      };
+
+      const feedback = await feedbackProcessor.generateFeedback(
+        messages,
+        currentTranscript,
+        userContext
+      );
+
+      if (feedback) {
+        ws.send(
+          JSON.stringify({
+            type: 'feedback_generated',
+            messageContent: currentTranscript,
+            feedback,
+          })
+        );
+      }
+    } catch (error) {
+      if (!isShuttingDown) {
+        console.error('[Server] Error generating feedback:', error);
+      }
+    }
+  });
+
   // Start the graph for this connection
   try {
     await connectionManager.start();
@@ -234,11 +281,13 @@ wss.on('connection', async (ws) => {
 
           // Update all processors
           flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+          feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
           connectionManager.setLanguage(newLanguageCode);
 
           // Reset conversation on language change
           connectionManager.reset();
           flashcardProcessors.get(connectionId)?.reset();
+          feedbackProcessors.get(connectionId)?.reset();
 
           // Send confirmation
           ws.send(
@@ -310,6 +359,7 @@ wss.on('connection', async (ws) => {
 
     // Clean up other processors
     flashcardProcessors.delete(connectionId);
+    feedbackProcessors.delete(connectionId);
     connectionAttributes.delete(connectionId);
   });
 });
diff --git a/frontend/src/components/FeedbackTooltip.tsx b/frontend/src/components/FeedbackTooltip.tsx
new file mode 100644
index 0000000..d259e94
--- /dev/null
+++ b/frontend/src/components/FeedbackTooltip.tsx
@@ -0,0 +1,58 @@
+import { useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+
+interface FeedbackTooltipProps {
+  feedback: string | null;
+  visible: boolean;
+  position: { x: number; y: number };
+  onMouseEnter?: () => void;
+  onMouseLeave?: () => void;
+}
+
+export function FeedbackTooltip({
+  feedback,
+  visible,
+  position,
+  onMouseEnter,
+  onMouseLeave,
+}: FeedbackTooltipProps) {
+  const tooltipRef = useRef<HTMLDivElement>(null);
+  const isLoading = feedback === null;
+
+  // Adjust position after content loads
+  useEffect(() => {
+    if (visible && tooltipRef.current && !isLoading) {
+      const tooltipRect = tooltipRef.current.getBoundingClientRect();
+      tooltipRef.current.style.top = `${position.y - tooltipRect.height}px`;
+    }
+  }, [visible, isLoading, position.y, feedback]);
+
+  if (!visible) return null;
+
+  const tooltipContent = (
+    <div
+      ref={tooltipRef}
+      className={`feedback-tooltip ${visible ? 'visible' : ''} ${isLoading ? 'loading' : ''}`}
+      style={{
+        left: `${position.x}px`,
+        top: `${position.y}px`,
+        maxWidth: '400px',
+      }}
+      onMouseEnter={onMouseEnter}
+      onMouseLeave={onMouseLeave}
+    >
+      <div className="feedback-content">
+        <span className="feedback-text">
+          {isLoading ? '' : feedback || 'No feedback available'}
+        </span>
+      </div>
+      <div className="feedback-loading">
+        <span></span>
+        <span></span>
+        <span></span>
+      </div>
+    </div>
+  );
+
+  return createPortal(tooltipContent, document.body);
+}
diff --git a/frontend/src/components/Message.tsx b/frontend/src/components/Message.tsx
index 4b05efe..7ecf307 100644
--- a/frontend/src/components/Message.tsx
+++ b/frontend/src/components/Message.tsx
@@ -1,12 +1,15 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 import type { ChatMessage } from '../types';
 import { TranslationTooltip } from './TranslationTooltip';
+import { FeedbackTooltip } from './FeedbackTooltip';
+import { useApp } from '../context/AppContext';
 
 interface MessageProps {
   message: ChatMessage;
 }
 
 export function Message({ message }: MessageProps) {
+  const { state } = useApp();
   const [showTooltip, setShowTooltip] = useState(false);
   const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });
   const messageRef = useRef<HTMLDivElement>(null);
@@ -14,8 +17,6 @@ export function Message({ message }: MessageProps) {
   const hideTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   const handleMouseEnter = useCallback(() => {
-    if (message.role !== 'teacher') return;
-
     if (hideTimeoutRef.current) {
       clearTimeout(hideTimeoutRef.current);
       hideTimeoutRef.current = null;
@@ -31,7 +32,7 @@ export function Message({ message }: MessageProps) {
         setShowTooltip(true);
       }
     }, 300);
-  }, [message.role]);
+  }, []);
 
   const handleMouseLeave = useCallback(() => {
     if (hoverTimeoutRef.current) {
@@ -62,6 +63,12 @@ export function Message({ message }: MessageProps) {
     };
   }, []);
 
+  // Get feedback for learner messages from the feedbackMap
+  const feedback =
+    message.role === 'learner'
+      ? (state.feedbackMap[message.content] ?? null)
+      : null;
+
   return (
     <>
       <div
@@ -81,6 +88,15 @@ export function Message({ message }: MessageProps) {
           onMouseLeave={handleTooltipMouseLeave}
         />
       )}
+      {message.role === 'learner' && (
+        <FeedbackTooltip
+          feedback={feedback}
+          visible={showTooltip}
+          position={tooltipPosition}
+          onMouseEnter={handleTooltipMouseEnter}
+          onMouseLeave={handleTooltipMouseLeave}
+        />
+      )}
     </>
   );
 }
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 1ac1901..91b69e9 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -14,6 +14,7 @@ import type {
   Language,
   ConnectionStatus,
   AudioStreamData,
+  FeedbackGeneratedPayload,
 } from '../types';
 import { Storage } from '../services/Storage';
 import { WebSocketClient } from '../services/WebSocketClient';
@@ -37,6 +38,10 @@ type AppAction =
   | { type: 'SET_SPEECH_DETECTED'; payload: boolean }
   | { type: 'SET_FLASHCARDS'; payload: Flashcard[] }
   | { type: 'ADD_FLASHCARDS'; payload: Flashcard[] }
+  | {
+      type: 'SET_FEEDBACK';
+      payload: { messageContent: string; feedback: string };
+    }
   | { type: 'RESET_STREAMING_STATE' }
   | { type: 'RESET_CONVERSATION' };
 
@@ -54,6 +59,7 @@ const createInitialState = (storage: Storage): AppState => ({
   isRecording: false,
   speechDetected: false,
   flashcards: [],
+  feedbackMap: {},
   userId: storage.getOrCreateUserId(),
 });
 
@@ -103,6 +109,14 @@ function appReducer(state: AppState, action: AppAction): AppState {
       );
       return { ...state, flashcards: [...state.flashcards, ...newCards] };
     }
+    case 'SET_FEEDBACK':
+      return {
+        ...state,
+        feedbackMap: {
+          ...state.feedbackMap,
+          [action.payload.messageContent]: action.payload.feedback,
+        },
+      };
     case 'RESET_STREAMING_STATE':
       return {
         ...state,
@@ -587,6 +601,11 @@ export function AppProvider({ children }: AppProviderProps) {
       dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
     });
 
+    wsClient.on('feedback_generated', (data) => {
+      const { messageContent, feedback } = data as FeedbackGeneratedPayload;
+      dispatch({ type: 'SET_FEEDBACK', payload: { messageContent, feedback } });
+    });
+
     wsClient.on('language_changed', (data) => {
       console.log(
         `Language changed to ${(data as { languageName: string }).languageName}`
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index 22f5d2a..13d18d9 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -220,6 +220,13 @@ export class WebSocketClient {
         this.emit('flashcards_generated', message.flashcards as Flashcard[]);
         break;
 
+      case 'feedback_generated':
+        this.emit('feedback_generated', {
+          messageContent: message.messageContent,
+          feedback: message.feedback,
+        });
+        break;
+
       case 'introduction_state_updated':
         this.emit('introduction_state_updated', message.introduction_state);
         break;
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 9e0ae96..dc25cc1 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -725,4 +725,108 @@ body {
 
 .message.teacher:hover {
     background: #e9eaec;
+}
+
+/* Feedback Tooltip for learner messages */
+.feedback-tooltip {
+    position: absolute;
+    z-index: 1000;
+    background: #2d4a3e;
+    color: #ffffff;
+    padding: 10px 14px;
+    border-radius: 8px;
+    font-size: 14px;
+    line-height: 1.4;
+    max-width: 400px;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.25);
+    opacity: 0;
+    visibility: hidden;
+    transform: translateY(4px);
+    transition: opacity 0.2s ease, transform 0.2s ease, visibility 0.2s;
+    pointer-events: none;
+}
+
+.feedback-tooltip.visible {
+    opacity: 1;
+    visibility: visible;
+    transform: translateY(0);
+    pointer-events: auto;
+}
+
+.feedback-tooltip::after {
+    content: '';
+    position: absolute;
+    bottom: -6px;
+    left: 20px;
+    width: 12px;
+    height: 12px;
+    background: #2d4a3e;
+    transform: rotate(45deg);
+    border-radius: 0 0 2px 0;
+}
+
+.feedback-content {
+    display: block;
+}
+
+.feedback-text {
+    display: block;
+    word-wrap: break-word;
+}
+
+.feedback-loading {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    padding: 4px 0;
+}
+
+.feedback-tooltip.loading .feedback-loading {
+    display: flex;
+}
+
+.feedback-tooltip.loading .feedback-content {
+    display: none;
+}
+
+.feedback-loading span {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: rgba(255, 255, 255, 0.7);
+    animation: feedback-dot 1.2s ease-in-out infinite;
+}
+
+.feedback-loading span:nth-child(1) {
+    animation-delay: 0s;
+}
+
+.feedback-loading span:nth-child(2) {
+    animation-delay: 0.15s;
+}
+
+.feedback-loading span:nth-child(3) {
+    animation-delay: 0.3s;
+}
+
+@keyframes feedback-dot {
+    0%, 60%, 100% {
+        opacity: 0.4;
+        transform: scale(0.8);
+    }
+    30% {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+/* Make learner messages show a subtle cursor hint for feedback */
+.message.learner {
+    cursor: help;
+    transition: background-color 0.15s ease;
+}
+
+.message.learner:hover {
+    background: #c8e6d5;
 }
\ No newline at end of file
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 64646c6..879568b 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -104,6 +104,11 @@ export interface LanguageChangedPayload {
   languageName: string;
 }
 
+export interface FeedbackGeneratedPayload {
+  messageContent: string;
+  feedback: string;
+}
+
 // App state
 export interface AppState {
   // Connection
@@ -128,6 +133,9 @@ export interface AppState {
   // Flashcards
   flashcards: Flashcard[];
 
+  // Feedback (keyed by user message content)
+  feedbackMap: Record<string, string>;
+
   // User
   userId: string;
 }

From e23a6df653e4b4af8a4d03ae84679aabb3a639c3 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 00:51:49 -0800
Subject: [PATCH 16/49] added logging and updated readme

---
 README.md                                     |  24 +-
 backend/config/languages.ts                   |   6 +-
 backend/config/llm.ts                         |  82 ++++++
 backend/config/server.ts                      | 106 +++++++
 backend/graphs/conversation-graph.ts          |  45 ++-
 backend/graphs/flashcard-graph.ts             |  22 +-
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   | 104 +++----
 .../nodes/dialog-prompt-builder-node.ts       |  19 +-
 .../graphs/nodes/interaction-queue-node.ts    |  31 +-
 backend/graphs/nodes/state-update-node.ts     |  15 +-
 backend/graphs/nodes/text-input-node.ts       |   5 +-
 .../graphs/nodes/transcript-extractor-node.ts |   6 +-
 .../graphs/nodes/tts-request-builder-node.ts  |   3 +-
 backend/graphs/response-feedback-graph.ts     |  20 +-
 backend/helpers/connection-manager.ts         | 137 ++++-----
 backend/helpers/feedback-processor.ts         |  13 +-
 backend/helpers/flashcard-processor.ts        |  15 +-
 backend/helpers/multimodal-stream-manager.ts  |   9 +-
 backend/server.ts                             |  85 +++---
 backend/types/index.ts                        |   6 -
 backend/types/settings.ts                     |  57 ----
 backend/utils/logger.ts                       |  55 ++++
 package-lock.json                             | 264 ++++++++++++++++++
 package.json                                  |   2 +
 24 files changed, 762 insertions(+), 369 deletions(-)
 create mode 100644 backend/config/llm.ts
 create mode 100644 backend/config/server.ts
 delete mode 100644 backend/types/settings.ts
 create mode 100644 backend/utils/logger.ts

diff --git a/README.md b/README.md
index 55e4f80..976007e 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,24 @@ ASSEMBLY_AI_API_KEY=your_api_key_here
 
 Get your Inworld Base64 API key from the [Inworld Portal](https://platform.inworld.ai/).
 
+## Environment Variables
+
+### Required
+
+| Variable | Description |
+|----------|-------------|
+| `INWORLD_API_KEY` | Your Inworld AI API key (Base64 encoded) from the [Inworld Portal](https://platform.inworld.ai/) |
+| `ASSEMBLY_AI_API_KEY` | Your Assembly AI API key for speech-to-text |
+
+### Optional
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `3000` | Server port number |
+| `LOG_LEVEL` | `info` | Logging level. Options: `trace`, `debug`, `info`, `warn`, `error`, `fatal` |
+| `NODE_ENV` | `development` | Environment mode. Set to `production` for JSON logs (no pretty-printing) |
+| `ASSEMBLY_AI_EAGERNESS` | `medium` | Turn detection sensitivity for speech-to-text. Options: `low` (conservative, allows thinking pauses), `medium` (balanced), `high` (aggressive, quick responses) |
+
 ### Step 4: Run the Application
 
 For development:
@@ -62,7 +80,9 @@ npm start
 language-learning-node/
 ├── backend/
 │   ├── config/               # Configuration
-│   │   └── languages.ts
+│   │   ├── languages.ts      # Language definitions and teacher personas
+│   │   ├── llm.ts            # LLM model configuration
+│   │   └── server.ts         # Server and audio settings
 │   ├── graphs/               # Graph definitions
 │   │   ├── nodes/            # Graph node implementations
 │   │   ├── conversation-graph.ts
@@ -76,6 +96,8 @@ language-learning-node/
 │   │   ├── multimodal-stream-manager.ts
 │   │   └── prompt-templates.ts
 │   ├── types/                # TypeScript type definitions
+│   ├── utils/                # Utility modules
+│   │   └── logger.ts         # Structured logging (pino)
 │   └── server.ts             # Backend server
 ├── frontend/                 # React frontend application
 │   ├── public/               # Static assets
diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index 58b8892..a1f5663 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -7,6 +7,10 @@
  * 2. The rest of the app will automatically support the new language
  */
 
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('Languages');
+
 export interface TeacherPersona {
   name: string;
   age: number;
@@ -277,7 +281,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
 export function getLanguageConfig(code: string): LanguageConfig {
   const config = SUPPORTED_LANGUAGES[code];
   if (!config) {
-    console.warn(`Language '${code}' not found, falling back to Spanish (es).`);
+    logger.warn({ requestedCode: code, fallback: 'es' }, 'language_not_found_using_fallback');
     return SUPPORTED_LANGUAGES['es'];
   }
   return config;
diff --git a/backend/config/llm.ts b/backend/config/llm.ts
new file mode 100644
index 0000000..66fbb83
--- /dev/null
+++ b/backend/config/llm.ts
@@ -0,0 +1,82 @@
+/**
+ * LLM Configuration
+ *
+ * Centralized configuration for all LLM providers and models used in the application.
+ * To change models or parameters, update this file instead of modifying graph code.
+ */
+
+export interface TextGenerationConfig {
+  maxNewTokens: number;
+  maxPromptLength: number;
+  temperature: number;
+  topP: number;
+  repetitionPenalty: number;
+  frequencyPenalty: number;
+  presencePenalty: number;
+}
+
+export interface LLMNodeConfig {
+  provider: string;
+  model: string;
+  stream: boolean;
+  textGenerationConfig: TextGenerationConfig;
+}
+
+export const llmConfig = {
+  /**
+   * Main conversation LLM - used for dialogue responses
+   * Streaming enabled for real-time TTS
+   */
+  conversation: {
+    provider: 'openai',
+    model: 'gpt-4.1-nano',
+    stream: true,
+    textGenerationConfig: {
+      maxNewTokens: 250,
+      maxPromptLength: 2000,
+      temperature: 1,
+      topP: 1,
+      repetitionPenalty: 1,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    },
+  } satisfies LLMNodeConfig,
+
+  /**
+   * Flashcard generation LLM - produces vocabulary cards
+   * Non-streaming, uses a more capable model for structured output
+   */
+  flashcard: {
+    provider: 'openai',
+    model: 'gpt-4.1-nano',
+    stream: false,
+    textGenerationConfig: {
+      maxNewTokens: 2500,
+      maxPromptLength: 100,
+      temperature: 1,
+      topP: 1,
+      repetitionPenalty: 1,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    },
+  } satisfies LLMNodeConfig,
+
+  /**
+   * Feedback generation LLM - provides learning feedback
+   * Non-streaming, lower temperature for consistent feedback
+   */
+  feedback: {
+    provider: 'openai',
+    model: 'gpt-4.1-nano',
+    stream: false,
+    textGenerationConfig: {
+      maxNewTokens: 100,
+      maxPromptLength: 2000,
+      temperature: 0.7,
+      topP: 1,
+      repetitionPenalty: 1,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    },
+  } satisfies LLMNodeConfig,
+} as const;
diff --git a/backend/config/server.ts b/backend/config/server.ts
new file mode 100644
index 0000000..bfda92c
--- /dev/null
+++ b/backend/config/server.ts
@@ -0,0 +1,106 @@
+/**
+ * Server Configuration
+ *
+ * Centralized configuration for server settings, audio processing, and external services.
+ * Environment variables can override defaults where appropriate.
+ */
+
+export interface AssemblyAITurnDetectionSettings {
+  endOfTurnConfidenceThreshold: number;
+  minEndOfTurnSilenceWhenConfident: number;
+  maxTurnSilence: number;
+  description: string;
+}
+
+export type AssemblyAIEagerness = 'low' | 'medium' | 'high';
+
+/**
+ * AssemblyAI turn detection presets based on their documentation
+ * @see https://www.assemblyai.com/docs/speech-to-text/universal-streaming/turn-detection
+ */
+const assemblyAIPresets: Record<AssemblyAIEagerness, AssemblyAITurnDetectionSettings> = {
+  /**
+   * Aggressive - Quick responses for rapid back-and-forth
+   * Use cases: Agent Assist, IVR replacements, Retail/E-commerce, Telecom
+   */
+  high: {
+    endOfTurnConfidenceThreshold: 0.4,
+    minEndOfTurnSilenceWhenConfident: 160,
+    maxTurnSilence: 400,
+    description: 'Aggressive - Quick responses for rapid back-and-forth (IVR, order confirmations)',
+  },
+
+  /**
+   * Balanced - Natural middle ground for most conversational turns
+   * Use cases: Customer Support, Tech Support, Financial Services, Travel
+   */
+  medium: {
+    endOfTurnConfidenceThreshold: 0.4,
+    minEndOfTurnSilenceWhenConfident: 400,
+    maxTurnSilence: 1280,
+    description: 'Balanced - Natural middle ground for most conversational turns',
+  },
+
+  /**
+   * Conservative - Patient, allows thinking pauses
+   * Use cases: Healthcare, Mental Health, Sales, Legal, Language Learning
+   */
+  low: {
+    endOfTurnConfidenceThreshold: 0.7,
+    minEndOfTurnSilenceWhenConfident: 800,
+    maxTurnSilence: 3600,
+    description: 'Conservative - Patient, allows thinking pauses (Language Learning, Healthcare)',
+  },
+};
+
+export const serverConfig = {
+  /**
+   * HTTP server port
+   */
+  port: Number(process.env.PORT) || 3000,
+
+  /**
+   * Audio processing settings
+   */
+  audio: {
+    /** Input sample rate from microphone (Hz) */
+    inputSampleRate: 16000,
+    /** TTS output sample rate (Hz) - Inworld TTS standard */
+    ttsSampleRate: 22050,
+  },
+
+  /**
+   * AssemblyAI speech-to-text configuration
+   */
+  assemblyAI: {
+    /** Turn detection eagerness level */
+    eagerness: (process.env.ASSEMBLY_AI_EAGERNESS || 'medium') as AssemblyAIEagerness,
+    /** Format turns in output (typically false for real-time processing) */
+    formatTurns: false,
+  },
+
+  /**
+   * Telemetry configuration for Inworld Runtime
+   */
+  telemetry: {
+    appName: 'inworld-language-tutor',
+    appVersion: '1.0.0',
+  },
+} as const;
+
+/**
+ * Get AssemblyAI turn detection settings for the configured eagerness level
+ */
+export function getAssemblyAISettings(): AssemblyAITurnDetectionSettings {
+  return assemblyAIPresets[serverConfig.assemblyAI.eagerness];
+}
+
+/**
+ * Get AssemblyAI turn detection settings for a specific eagerness level
+ * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
+ */
+export function getAssemblyAISettingsForEagerness(
+  eagerness: AssemblyAIEagerness
+): AssemblyAITurnDetectionSettings {
+  return assemblyAIPresets[eagerness];
+}
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 2b8687c..85e1b82 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -30,17 +30,17 @@ import { StateUpdateNode } from './nodes/state-update-node.js';
 import { TextInputNode } from './nodes/text-input-node.js';
 import { TranscriptExtractorNode } from './nodes/transcript-extractor-node.js';
 import { TTSRequestBuilderNode } from './nodes/tts-request-builder-node.js';
-import {
-  ConnectionsMap,
-  TextInput,
-  INPUT_SAMPLE_RATE,
-  TTS_SAMPLE_RATE,
-} from '../types/index.js';
+import { ConnectionsMap, TextInput } from '../types/index.js';
 import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
-import { getAssemblyAISettingsForEagerness } from '../types/settings.js';
+import { llmConfig } from '../config/llm.js';
+import {
+  serverConfig,
+  getAssemblyAISettings,
+} from '../config/server.js';
+import { graphLogger as logger } from '../utils/logger.js';
 
 export interface ConversationGraphConfig {
   assemblyAIApiKey: string;
@@ -81,8 +81,9 @@ export class ConversationGraphWrapper {
     const langConfig = getLanguageConfig(defaultLanguageCode);
     const postfix = `-lang-learning`;
 
-    console.log(
-      `[ConversationGraph] Creating graph for ${langConfig.name} (${defaultLanguageCode})`
+    logger.info(
+      { language: langConfig.name, languageCode: defaultLanguageCode },
+      'creating_conversation_graph'
     );
 
     // ============================================================
@@ -93,14 +94,14 @@ export class ConversationGraphWrapper {
     const audioInputNode = new ProxyNode({ id: `audio-input-proxy${postfix}` });
 
     // AssemblyAI STT with built-in VAD (always uses multilingual model)
-    const turnDetectionSettings = getAssemblyAISettingsForEagerness('medium');
+    const turnDetectionSettings = getAssemblyAISettings();
     const assemblyAISTTNode = new AssemblyAISTTWebSocketNode({
       id: `assembly-ai-stt-ws-node${postfix}`,
       config: {
         apiKey: assemblyAIApiKey,
         connections: connections,
-        sampleRate: INPUT_SAMPLE_RATE,
-        formatTurns: false,
+        sampleRate: serverConfig.audio.inputSampleRate,
+        formatTurns: serverConfig.assemblyAI.formatTurns,
         endOfTurnConfidenceThreshold:
           turnDetectionSettings.endOfTurnConfidenceThreshold,
         minEndOfTurnSilenceWhenConfident:
@@ -134,18 +135,10 @@ export class ConversationGraphWrapper {
     // LLM Node - uses Inworld Runtime's remote LLM
     const llmNode = new RemoteLLMChatNode({
       id: `llm-node${postfix}`,
-      provider: 'openai',
-      modelName: 'gpt-4.1-nano',
-      stream: true,
-      textGenerationConfig: {
-        maxNewTokens: 250,
-        maxPromptLength: 2000,
-        temperature: 1,
-        topP: 1,
-        repetitionPenalty: 1,
-        frequencyPenalty: 0,
-        presencePenalty: 0,
-      },
+      provider: llmConfig.conversation.provider,
+      modelName: llmConfig.conversation.model,
+      stream: llmConfig.conversation.stream,
+      textGenerationConfig: llmConfig.conversation.textGenerationConfig,
       reportToClient: true,
     });
 
@@ -174,7 +167,7 @@ export class ConversationGraphWrapper {
       id: `tts-node${postfix}`,
       speakerId: langConfig.ttsConfig.speakerId,
       modelId: langConfig.ttsConfig.modelId,
-      sampleRate: TTS_SAMPLE_RATE,
+      sampleRate: serverConfig.audio.ttsSampleRate,
       temperature: langConfig.ttsConfig.temperature,
       speakingRate: langConfig.ttsConfig.speakingRate,
       languageCode: langConfig.ttsConfig.languageCode,
@@ -280,7 +273,7 @@ export class ConversationGraphWrapper {
 
     const graph = graphBuilder.build();
 
-    console.log('[ConversationGraph] Graph built successfully');
+    logger.info('conversation_graph_built');
 
     return new ConversationGraphWrapper({
       graph,
diff --git a/backend/graphs/flashcard-graph.ts b/backend/graphs/flashcard-graph.ts
index 66835ec..6f8b108 100644
--- a/backend/graphs/flashcard-graph.ts
+++ b/backend/graphs/flashcard-graph.ts
@@ -12,6 +12,8 @@ import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { flashcardPromptTemplate } from '../helpers/prompt-templates.js';
 import { v4 } from 'uuid';
 import { Flashcard } from '../helpers/flashcard-processor.js';
+import { llmConfig } from '../config/llm.js';
+import { flashcardLogger as logger } from '../utils/logger.js';
 
 class FlashcardPromptBuilderNode extends CustomNode {
   async process(
@@ -60,7 +62,7 @@ class FlashcardParserNode extends CustomNode {
         };
       }
     } catch (error) {
-      console.error('Failed to parse flashcard JSON:', error);
+      logger.error({ err: error }, 'failed_to_parse_flashcard_json');
     }
 
     return {
@@ -92,18 +94,10 @@ function createFlashcardGraph(): Graph {
   });
   const llmNode = new RemoteLLMChatNode({
     id: 'llm_node',
-    provider: 'openai',
-    modelName: 'gpt-4o-mini',
-    stream: false,
-    textGenerationConfig: {
-      maxNewTokens: 2500,
-      maxPromptLength: 100,
-      repetitionPenalty: 1,
-      topP: 1,
-      temperature: 1,
-      frequencyPenalty: 0,
-      presencePenalty: 0,
-    },
+    provider: llmConfig.flashcard.provider,
+    modelName: llmConfig.flashcard.model,
+    stream: llmConfig.flashcard.stream,
+    textGenerationConfig: llmConfig.flashcard.textGenerationConfig,
   });
   const parserNode = new FlashcardParserNode({ id: 'flashcard-parser' });
 
@@ -133,7 +127,7 @@ let flashcardGraph: Graph | null = null;
  */
 export function getFlashcardGraph(): Graph {
   if (!flashcardGraph) {
-    console.log('Creating flashcard graph');
+    logger.info('creating_flashcard_graph');
     flashcardGraph = createFlashcardGraph();
   }
   return flashcardGraph;
diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index 846f1ca..5f15b91 100644
--- a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -5,6 +5,9 @@ import { v4 as uuidv4 } from 'uuid';
 
 import { Connection } from '../../types/index.js';
 import { audioDataToPCM16 } from '../../helpers/audio-utils.js';
+import { createLogger } from '../../utils/logger.js';
+
+const logger = createLogger('AssemblyAI');
 
 /**
  * Configuration interface for AssemblyAISTTWebSocketNode
@@ -63,9 +66,7 @@ class AssemblyAISession {
       isExpired
     ) {
       if (isExpired) {
-        console.log(
-          `[AssemblyAI] Session ${this.sessionId} expired, reconnecting`
-        );
+        logger.info({ sessionId: this.sessionId }, 'session_expired_reconnecting');
       }
       this.closeWebSocket();
       this.initializeWebSocket();
@@ -80,9 +81,7 @@ class AssemblyAISession {
   }
 
   private initializeWebSocket(): void {
-    console.log(
-      `[AssemblyAI] Initializing WebSocket for session ${this.sessionId}`
-    );
+    logger.debug({ sessionId: this.sessionId }, 'initializing_websocket');
 
     this.wsConnectionPromise = new Promise<void>((resolve, reject) => {
       this.ws = new WebSocket(this.url, {
@@ -90,9 +89,7 @@ class AssemblyAISession {
       });
 
       this.ws.on('open', () => {
-        console.log(
-          `[AssemblyAI] WebSocket opened for session ${this.sessionId}`
-        );
+        logger.debug({ sessionId: this.sessionId }, 'websocket_opened');
         this.wsReady = true;
         resolve();
       });
@@ -104,9 +101,7 @@ class AssemblyAISession {
           if (message.type === 'Begin') {
             this.assemblySessionId = message.id || message.session_id || '';
             this.sessionExpiresAt = message.expires_at || 0;
-            console.log(
-              `[AssemblyAI] Session began: ${this.assemblySessionId}`
-            );
+            logger.debug({ assemblySessionId: this.assemblySessionId }, 'session_began');
           }
         } catch {
           // Ignore parsing errors
@@ -114,15 +109,13 @@ class AssemblyAISession {
       });
 
       this.ws.on('error', (error: Error) => {
-        console.error(`[AssemblyAI] WebSocket error:`, error);
+        logger.error({ err: error }, 'websocket_error');
         this.wsReady = false;
         reject(error);
       });
 
       this.ws.on('close', (code: number, reason: Buffer) => {
-        console.log(
-          `[AssemblyAI] WebSocket closed [code:${code}] [reason:${reason.toString()}]`
-        );
+        logger.debug({ code, reason: reason.toString() }, 'websocket_closed');
         this.wsReady = false;
       });
     });
@@ -159,9 +152,7 @@ class AssemblyAISession {
 
   private closeDueToInactivity(): void {
     const inactiveFor = Date.now() - this.lastActivityTime;
-    console.log(
-      `[AssemblyAI] Closing session ${this.sessionId} due to inactivity (${inactiveFor}ms)`
-    );
+    logger.info({ sessionId: this.sessionId, inactiveMs: inactiveFor }, 'closing_due_to_inactivity');
     this.shouldStopProcessing = true;
     this.close();
     this.onCleanup(this.sessionId);
@@ -175,7 +166,7 @@ class AssemblyAISession {
           this.ws.close();
         }
       } catch (e) {
-        console.warn('[AssemblyAI] Error closing socket:', e);
+        logger.warn({ err: e }, 'error_closing_socket');
       }
       this.ws = null;
       this.wsReady = false;
@@ -252,9 +243,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       config.minEndOfTurnSilenceWhenConfident ?? 800;
     this.maxTurnSilence = config.maxTurnSilence ?? 3600;
 
-    console.log(
-      `[AssemblyAI] Configured [threshold:${this.endOfTurnConfidenceThreshold}] [minSilence:${this.minEndOfTurnSilenceWhenConfident}ms] [maxSilence:${this.maxTurnSilence}ms]`
-    );
+    logger.info({
+      threshold: this.endOfTurnConfidenceThreshold,
+      minSilenceMs: this.minEndOfTurnSilenceWhenConfident,
+      maxSilenceMs: this.maxTurnSilence,
+    }, 'stt_node_configured');
   }
 
   /**
@@ -275,9 +268,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
-    console.log(
-      `[AssemblyAI] Connecting [model:universal-streaming-multilingual] [threshold:${this.endOfTurnConfidenceThreshold}] [maxSilence:${this.maxTurnSilence}ms]`
-    );
+    logger.debug({
+      model: 'universal-streaming-multilingual',
+      threshold: this.endOfTurnConfidenceThreshold,
+      maxSilenceMs: this.maxTurnSilence,
+    }, 'connecting_to_assemblyai');
 
     return url;
   }
@@ -336,7 +331,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         : currentId;
     const nextInteractionId = `${baseId}#${iteration}`;
 
-    console.log(`[AssemblyAI] Starting transcription [iteration:${iteration}]`);
+    logger.debug({ iteration }, 'starting_transcription');
 
     // State tracking
     let transcriptText = '';
@@ -404,9 +399,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
               );
 
               if (connection?.onSpeechDetected && !speechDetected) {
-                console.log(
-                  `[AssemblyAI] Speech detected [iteration:${iteration}]`
-                );
+                logger.debug({ iteration }, 'speech_detected');
                 speechDetected = true;
                 connection.onSpeechDetected(nextInteractionId);
               }
@@ -421,15 +414,11 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             // Stitch the pending transcript with the new one
             finalTranscript =
               `${connection.pendingTranscript} ${transcript}`.trim();
-            console.log(
-              `[AssemblyAI] Stitched transcript [iteration:${iteration}]: "${finalTranscript.substring(0, 80)}..."`
-            );
+            logger.debug({ iteration, transcriptSnippet: finalTranscript.substring(0, 80) }, 'stitched_transcript');
             // Clear the pending transcript
             connection.pendingTranscript = undefined;
           } else {
-            console.log(
-              `[AssemblyAI] Turn detected [iteration:${iteration}]: "${transcript.substring(0, 50)}..."`
-            );
+            logger.debug({ iteration, transcriptSnippet: transcript.substring(0, 50) }, 'turn_detected');
           }
 
           // Clear interrupt flag for new processing
@@ -442,12 +431,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
           if (session) session.shouldStopProcessing = true;
           turnResolve(finalTranscript);
         } else if (msgType === 'Termination') {
-          console.log(
-            `[AssemblyAI] Session terminated [iteration:${iteration}]`
-          );
+          logger.debug({ iteration }, 'session_terminated');
         }
       } catch (error) {
-        console.error(`[AssemblyAI] Error handling message:`, error);
+        logger.error({ err: error }, 'error_handling_message');
       }
     };
 
@@ -468,18 +455,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             if (session?.shouldStopProcessing) break;
 
             if (maxDurationReached && !transcriptText) {
-              console.warn(
-                `[AssemblyAI] Max transcription duration reached [${this.MAX_TRANSCRIPTION_DURATION_MS}ms]`
-              );
+              logger.warn({ maxDurationMs: this.MAX_TRANSCRIPTION_DURATION_MS }, 'max_transcription_duration_reached');
               break;
             }
 
             const result = await multimodalStream.next();
 
             if (result.done) {
-              console.log(
-                `[AssemblyAI] Multimodal stream exhausted [iteration:${iteration}] [chunks:${audioChunkCount}]`
-              );
+              logger.debug({ iteration, audioChunkCount }, 'multimodal_stream_exhausted');
               isStreamExhausted = true;
               break;
             }
@@ -490,9 +473,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
             // Handle text input
             if (content.text !== undefined && content.text !== null) {
-              console.log(
-                `[AssemblyAI] Text input detected [iteration:${iteration}]: "${content.text.substring(0, 50)}..."`
-              );
+              logger.debug({ iteration, textSnippet: content.text.substring(0, 50) }, 'text_input_detected');
               isTextInput = true;
               textContent = content.text;
               transcriptText = content.text;
@@ -515,7 +496,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             session?.sendAudio(pcm16Data);
           }
         } catch (error) {
-          console.error(`[AssemblyAI] Error processing audio:`, error);
+          logger.error({ err: error }, 'error_processing_audio');
           errorOccurred = true;
           errorMessage = error instanceof Error ? error.message : String(error);
           throw error;
@@ -536,9 +517,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         !turnCompleted &&
         !maxDurationReached
       ) {
-        console.log(
-          `[AssemblyAI] Audio ended before turn, waiting ${this.TURN_COMPLETION_TIMEOUT_MS}ms`
-        );
+        logger.debug({ waitMs: this.TURN_COMPLETION_TIMEOUT_MS }, 'audio_ended_before_turn_waiting');
 
         // Send silence to keep connection alive - AssemblyAI needs continuous audio
         const silenceIntervalMs = 100;
@@ -567,16 +546,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         clearInterval(silenceTimer);
 
         if (waitResult.winner === 'timeout' && !turnCompleted) {
-          console.warn(`[AssemblyAI] Timed out waiting for turn`);
+          logger.warn('timed_out_waiting_for_turn');
           turnReject?.(new Error('Timed out waiting for turn completion'));
         }
       }
 
       await audioProcessingPromise.catch(() => {});
 
-      console.log(
-        `[AssemblyAI] Transcription complete [iteration:${iteration}]: "${transcriptText?.substring(0, 50)}..."`
-      );
+      logger.debug({ iteration, transcriptSnippet: transcriptText?.substring(0, 50) }, 'transcription_complete');
 
       if (turnDetected) {
         connection.state.interactionId = '';
@@ -607,10 +584,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         text_content: textContent,
       });
     } catch (error) {
-      console.error(
-        `[AssemblyAI] Transcription failed [iteration:${iteration}]:`,
-        error
-      );
+      logger.error({ err: error, iteration }, 'transcription_failed');
 
       const taggedStream = Object.assign(multimodalStream, {
         type: 'MultimodalContent',
@@ -650,23 +624,21 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     try {
       connection.onPartialTranscript(text, interactionId);
     } catch (error) {
-      console.error('[AssemblyAI] Error sending partial transcript:', error);
+      logger.error({ err: error }, 'error_sending_partial_transcript');
     }
   }
 
   async closeSession(sessionId: string): Promise<void> {
     const session = this.sessions.get(sessionId);
     if (session) {
-      console.log(`[AssemblyAI] Closing session: ${sessionId}`);
+      logger.debug({ sessionId }, 'closing_session');
       await session.close();
       this.sessions.delete(sessionId);
     }
   }
 
   async destroy(): Promise<void> {
-    console.log(
-      `[AssemblyAI] Destroying node: closing ${this.sessions.size} sessions`
-    );
+    logger.info({ sessionCount: this.sessions.size }, 'destroying_node');
 
     const promises: Promise<void>[] = [];
     for (const session of this.sessions.values()) {
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index ac4d416..1127a73 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -13,6 +13,7 @@ import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { ConnectionsMap, State } from '../../types/index.js';
 import { getLanguageConfig } from '../../config/languages.js';
 import { conversationTemplate } from '../../helpers/prompt-templates.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class DialogPromptBuilderNode extends CustomNode {
   constructor(props: {
@@ -31,8 +32,9 @@ export class DialogPromptBuilderNode extends CustomNode {
     _context: ProcessContext,
     state: State
   ): Promise<GraphTypes.LLMChatRequest> {
-    console.log(
-      `[DialogPromptBuilder] Building prompt for ${state.languageCode || 'es'}, ${state.messages?.length || 0} messages`
+    logger.debug(
+      { languageCode: state.languageCode || 'es', messageCount: state.messages?.length || 0 },
+      'building_prompt'
     );
 
     // Get language config from state
@@ -55,10 +57,9 @@ export class DialogPromptBuilderNode extends CustomNode {
     const currentInput =
       lastMessage?.role === 'user' ? lastMessage.content : '';
 
-    console.log('[DialogPromptBuilder] Language:', langConfig.name);
-    console.log(
-      '[DialogPromptBuilder] Messages in history:',
-      historyMessages.length
+    logger.debug(
+      { language: langConfig.name, historyLength: historyMessages.length },
+      'prompt_context'
     );
 
     const templateData = {
@@ -75,9 +76,9 @@ export class DialogPromptBuilderNode extends CustomNode {
     const renderedPrompt = await builder.build(templateData);
 
     // Debug: Log a snippet of the rendered prompt
-    const promptSnippet = renderedPrompt.substring(0, 400);
-    console.log(
-      `[DialogPromptBuilder] Rendered prompt (first 400 chars): ${promptSnippet}...`
+    logger.debug(
+      { promptSnippet: renderedPrompt.substring(0, 400) },
+      'prompt_rendered'
     );
 
     // Return LLMChatRequest for the LLM node
diff --git a/backend/graphs/nodes/interaction-queue-node.ts b/backend/graphs/nodes/interaction-queue-node.ts
index 74aa166..d8cf668 100644
--- a/backend/graphs/nodes/interaction-queue-node.ts
+++ b/backend/graphs/nodes/interaction-queue-node.ts
@@ -15,6 +15,7 @@ import {
   State,
   TextInput,
 } from '../../types/index.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class InteractionQueueNode extends CustomNode {
   private connections: ConnectionsMap;
@@ -37,9 +38,7 @@ export class InteractionQueueNode extends CustomNode {
     state: State
   ): TextInput {
     const sessionId = interactionInfo.sessionId;
-    console.log(
-      `[InteractionQueue] Processing interaction ${interactionInfo.interactionId}`
-    );
+    logger.debug({ interactionId: interactionInfo.interactionId }, 'processing_interaction');
 
     // Get current voiceId from connection state
     const connection = this.connections[sessionId];
@@ -56,9 +55,7 @@ export class InteractionQueueNode extends CustomNode {
         QUEUED_PREFIX + interactionInfo.interactionId,
         interactionInfo.text
       );
-      console.log(
-        `[InteractionQueue] New interaction queued: ${interactionInfo.interactionId}`
-      );
+      logger.debug({ interactionId: interactionInfo.interactionId }, 'interaction_queued');
     }
 
     // Get all keys and categorize them
@@ -89,13 +86,11 @@ export class InteractionQueueNode extends CustomNode {
       return getIteration(a) - getIteration(b);
     });
 
-    console.log(
-      `[InteractionQueue] State: queued=${queuedIds.length}, completed=${completedCount}, running=${runningCount}`
-    );
+    logger.debug({ queued: queuedIds.length, completed: completedCount, running: runningCount }, 'queue_state');
 
     // Decide if we should start processing the next interaction
     if (queuedIds.length === 0) {
-      console.log('[InteractionQueue] No interactions to process');
+      logger.debug('no_interactions_to_process');
       return {
         text: '',
         sessionId: sessionId,
@@ -105,7 +100,7 @@ export class InteractionQueueNode extends CustomNode {
     }
 
     if (queuedIds.length === completedCount) {
-      console.log('[InteractionQueue] All interactions completed');
+      logger.debug('all_interactions_completed');
       return {
         text: '',
         sessionId: sessionId,
@@ -122,7 +117,7 @@ export class InteractionQueueNode extends CustomNode {
 
       // Try to mark as running
       if (dataStore.has(runningKey) || !dataStore.add(runningKey, '')) {
-        console.log(`[InteractionQueue] Interaction ${nextId} already started`);
+        logger.debug({ interactionId: nextId }, 'interaction_already_started');
         return {
           text: '',
           sessionId: sessionId,
@@ -133,9 +128,7 @@ export class InteractionQueueNode extends CustomNode {
 
       const queuedText = dataStore.get(QUEUED_PREFIX + nextId) as string;
       if (!queuedText) {
-        console.error(
-          `[InteractionQueue] Failed to retrieve text for ${nextId}`
-        );
+        logger.error({ interactionId: nextId }, 'failed_to_retrieve_text');
         return {
           text: '',
           sessionId: sessionId,
@@ -144,9 +137,7 @@ export class InteractionQueueNode extends CustomNode {
         };
       }
 
-      console.log(
-        `[InteractionQueue] Starting LLM processing: "${queuedText.substring(0, 50)}..."`
-      );
+      logger.debug({ textSnippet: queuedText.substring(0, 50) }, 'starting_llm_processing');
 
       return {
         text: queuedText,
@@ -156,9 +147,7 @@ export class InteractionQueueNode extends CustomNode {
       };
     } else {
       // An interaction is currently running, wait
-      console.log(
-        `[InteractionQueue] Waiting for interaction ${queuedIds[completedCount]}`
-      );
+      logger.debug({ waitingFor: queuedIds[completedCount] }, 'waiting_for_interaction');
       return {
         text: '',
         sessionId: sessionId,
diff --git a/backend/graphs/nodes/state-update-node.ts b/backend/graphs/nodes/state-update-node.ts
index 23f7fed..4fb2917 100644
--- a/backend/graphs/nodes/state-update-node.ts
+++ b/backend/graphs/nodes/state-update-node.ts
@@ -11,6 +11,7 @@
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { v4 as uuidv4 } from 'uuid';
 import { ConnectionsMap, State } from '../../types/index.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class StateUpdateNode extends CustomNode {
   private connections: ConnectionsMap;
@@ -29,9 +30,7 @@ export class StateUpdateNode extends CustomNode {
 
   process(context: ProcessContext, llmOutput: string): State {
     const sessionId = context.getDatastore().get('sessionId') as string;
-    console.log(
-      `[StateUpdateNode] Processing [length:${llmOutput?.length || 0}]`
-    );
+    logger.debug({ outputLength: llmOutput?.length || 0 }, 'state_update_processing');
 
     const connection = this.connections[sessionId];
     if (connection?.unloaded) {
@@ -43,9 +42,7 @@ export class StateUpdateNode extends CustomNode {
 
     // Only add assistant message if there's actual content
     if (llmOutput && llmOutput.trim().length > 0) {
-      console.log(
-        `[StateUpdateNode] Adding assistant message: "${llmOutput.substring(0, 50)}..."`
-      );
+      logger.debug({ messageSnippet: llmOutput.substring(0, 50) }, 'adding_assistant_message');
       connection.state.messages.push({
         role: 'assistant',
         content: llmOutput,
@@ -53,15 +50,13 @@ export class StateUpdateNode extends CustomNode {
         timestamp: new Date().toISOString(),
       });
     } else {
-      console.log('[StateUpdateNode] Skipping empty message');
+      logger.debug('skipping_empty_message');
     }
 
     // Mark interaction as completed
     const dataStore = context.getDatastore();
     dataStore.add('c' + connection.state.interactionId, '');
-    console.log(
-      `[StateUpdateNode] Marked interaction ${connection.state.interactionId} as completed`
-    );
+    logger.debug({ interactionId: connection.state.interactionId }, 'interaction_completed');
 
     return connection.state;
   }
diff --git a/backend/graphs/nodes/text-input-node.ts b/backend/graphs/nodes/text-input-node.ts
index 6d5fa67..d933afe 100644
--- a/backend/graphs/nodes/text-input-node.ts
+++ b/backend/graphs/nodes/text-input-node.ts
@@ -10,6 +10,7 @@
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { v4 as uuidv4 } from 'uuid';
 import { ConnectionsMap, State, TextInput } from '../../types/index.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class TextInputNode extends CustomNode {
   private connections: ConnectionsMap;
@@ -27,9 +28,7 @@ export class TextInputNode extends CustomNode {
   }
 
   process(_context: ProcessContext, input: TextInput): State {
-    console.log(
-      `[TextInputNode] Processing: "${input.text?.substring(0, 50)}..."`
-    );
+    logger.debug({ textSnippet: input.text?.substring(0, 50) }, 'text_input_processing');
 
     const { text, interactionId, sessionId } = input;
 
diff --git a/backend/graphs/nodes/transcript-extractor-node.ts b/backend/graphs/nodes/transcript-extractor-node.ts
index 1b47e1c..ed38048 100644
--- a/backend/graphs/nodes/transcript-extractor-node.ts
+++ b/backend/graphs/nodes/transcript-extractor-node.ts
@@ -7,6 +7,7 @@
 import { DataStreamWithMetadata } from '@inworld/runtime';
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { InteractionInfo } from '../../types/index.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class TranscriptExtractorNode extends CustomNode {
   constructor(props?: { id?: string; reportToClient?: boolean }) {
@@ -33,8 +34,9 @@ export class TranscriptExtractorNode extends CustomNode {
     const iteration = (metadata.iteration as number) || 1;
     const interactionId = String(metadata.interactionId || iteration);
 
-    console.log(
-      `[TranscriptExtractor] Processing [iteration:${iteration}]: "${transcript?.substring(0, 50)}..." [complete:${interactionComplete}]`
+    logger.debug(
+      { iteration, transcriptSnippet: transcript?.substring(0, 50), interactionComplete },
+      'transcript_extracted'
     );
 
     return {
diff --git a/backend/graphs/nodes/tts-request-builder-node.ts b/backend/graphs/nodes/tts-request-builder-node.ts
index df1caa4..2c585c9 100644
--- a/backend/graphs/nodes/tts-request-builder-node.ts
+++ b/backend/graphs/nodes/tts-request-builder-node.ts
@@ -8,6 +8,7 @@
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import { ConnectionsMap } from '../../types/index.js';
 import { getLanguageConfig } from '../../config/languages.js';
+import { graphLogger as logger } from '../../utils/logger.js';
 
 export class TTSRequestBuilderNode extends CustomNode {
   private connections: ConnectionsMap;
@@ -51,7 +52,7 @@ export class TTSRequestBuilderNode extends CustomNode {
     }
     voiceId = voiceId || this.defaultVoiceId;
 
-    console.log(`[TTSRequestBuilder] Building TTS request [voice:${voiceId}]`);
+    logger.debug({ voiceId }, 'building_tts_request');
 
     return GraphTypes.TTSRequest.withStream(textStream, {
       id: voiceId,
diff --git a/backend/graphs/response-feedback-graph.ts b/backend/graphs/response-feedback-graph.ts
index 1d486e9..55c8365 100644
--- a/backend/graphs/response-feedback-graph.ts
+++ b/backend/graphs/response-feedback-graph.ts
@@ -9,6 +9,8 @@ import {
 } from '@inworld/runtime/graph';
 import { GraphTypes } from '@inworld/runtime/common';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
+import { llmConfig } from '../config/llm.js';
+import { feedbackLogger as logger } from '../utils/logger.js';
 
 export interface ResponseFeedbackInput {
   messages: Array<{ role: string; content: string }>;
@@ -87,18 +89,10 @@ function createResponseFeedbackGraph(): Graph {
   });
   const llmNode = new RemoteLLMChatNode({
     id: 'llm-node',
-    provider: 'openai',
-    modelName: 'gpt-4.1-nano',
-    stream: false,
-    textGenerationConfig: {
-      maxNewTokens: 100,
-      maxPromptLength: 2000,
-      repetitionPenalty: 1,
-      topP: 1,
-      temperature: 0.7,
-      frequencyPenalty: 0,
-      presencePenalty: 0,
-    },
+    provider: llmConfig.feedback.provider,
+    modelName: llmConfig.feedback.model,
+    stream: llmConfig.feedback.stream,
+    textGenerationConfig: llmConfig.feedback.textGenerationConfig,
   });
   const extractorNode = new FeedbackExtractorNode({ id: 'feedback-extractor' });
 
@@ -128,7 +122,7 @@ let responseFeedbackGraph: Graph | null = null;
  */
 export function getResponseFeedbackGraph(): Graph {
   if (!responseFeedbackGraph) {
-    console.log('Creating response feedback graph');
+    logger.info('creating_response_feedback_graph');
     responseFeedbackGraph = createResponseFeedbackGraph();
   }
   return responseFeedbackGraph;
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index a6c1905..32e1ef9 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -14,16 +14,14 @@ import { GraphTypes } from '@inworld/runtime/graph';
 import { ConversationGraphWrapper } from '../graphs/conversation-graph.js';
 import { MultimodalStreamManager } from './multimodal-stream-manager.js';
 import { decodeBase64ToFloat32 } from './audio-utils.js';
-import {
-  ConnectionsMap,
-  INPUT_SAMPLE_RATE,
-  TTS_SAMPLE_RATE,
-} from '../types/index.js';
+import { ConnectionsMap } from '../types/index.js';
 import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
   LanguageConfig,
 } from '../config/languages.js';
+import { serverConfig } from '../config/server.js';
+import { createSessionLogger } from '../utils/logger.js';
 
 export class ConnectionManager {
   private sessionId: string;
@@ -35,6 +33,7 @@ export class ConnectionManager {
   private isDestroyed = false;
   private languageCode: string;
   private languageConfig: LanguageConfig;
+  private logger: ReturnType<typeof createSessionLogger>;
 
   // Callback for flashcard processing
   private flashcardCallback:
@@ -67,6 +66,7 @@ export class ConnectionManager {
     this.languageCode = languageCode;
     this.languageConfig = getLanguageConfig(languageCode);
     this.multimodalStreamManager = new MultimodalStreamManager();
+    this.logger = createSessionLogger('ConnectionManager', sessionId);
 
     // Initialize connection state
     this.connections[sessionId] = {
@@ -87,18 +87,14 @@ export class ConnectionManager {
         this.handlePartialTranscript(text, interactionId),
     };
 
-    console.log(
-      `[ConnectionManager] Created for session ${sessionId} with language ${this.languageConfig.name}`
-    );
+    this.logger.info({ language: this.languageConfig.name }, 'connection_manager_created');
   }
 
   /**
    * Start the long-running graph execution
    */
   async start(): Promise<void> {
-    console.log(
-      `[ConnectionManager] Starting graph for session ${this.sessionId}`
-    );
+    this.logger.info('starting_graph');
 
     // Create the multimodal stream generator
     const multimodalStream = this.createMultimodalStreamGenerator();
@@ -109,7 +105,7 @@ export class ConnectionManager {
     // Don't await - the graph runs continuously
     this.graphExecution.catch((error) => {
       if (!this.isDestroyed) {
-        console.error(`[ConnectionManager] Graph execution error:`, error);
+        this.logger.error({ err: error }, 'graph_execution_error');
       }
     });
   }
@@ -139,9 +135,7 @@ export class ConnectionManager {
       type: 'MultimodalContent',
     });
 
-    console.log(
-      `[ConnectionManager] Starting graph execution for ${this.sessionId}`
-    );
+    this.logger.info('graph_execution_started');
 
     const { outputStream } = await this.graphWrapper.graph.start(taggedStream, {
       executionId: this.sessionId,
@@ -169,15 +163,13 @@ export class ConnectionManager {
       }
     } catch (error) {
       if (!this.isDestroyed) {
-        console.error(`[ConnectionManager] Error processing output:`, error);
+        this.logger.error({ err: error }, 'output_processing_error');
       }
     } finally {
       connection.currentAudioExecutionStream = undefined;
     }
 
-    console.log(
-      `[ConnectionManager] Graph execution completed for ${this.sessionId}`
-    );
+    this.logger.info('graph_execution_completed');
   }
 
   /**
@@ -203,9 +195,7 @@ export class ConnectionManager {
         string: (data: unknown) => {
           transcription = String(data);
           if (transcription.trim()) {
-            console.log(
-              `[ConnectionManager] Transcription: "${transcription}"`
-            );
+            this.logger.debug({ transcription }, 'transcription_received');
             this.sendToClient({
               type: 'transcription',
               text: transcription.trim(),
@@ -225,9 +215,7 @@ export class ConnectionManager {
           // Only send final transcriptions (interactionComplete=true) to avoid duplicates
           if (data.text && data.interactionComplete) {
             transcription = data.text;
-            console.log(
-              `[ConnectionManager] Transcription (final): "${transcription}"`
-            );
+            this.logger.debug({ transcription }, 'transcription_final');
 
             // Mark start of response processing for utterance stitching
             this.markProcessingStart(transcription);
@@ -243,7 +231,7 @@ export class ConnectionManager {
         // Handle LLM response stream
         ContentStream: async (streamData: unknown) => {
           const stream = streamData as GraphTypes.ContentStream;
-          console.log('[ConnectionManager] Processing LLM ContentStream...');
+          this.logger.debug('processing_llm_content_stream');
           // Use array + join instead of string concatenation for O(n) vs O(n²)
           const responseChunks: string[] = [];
           let wasInterrupted = false;
@@ -253,9 +241,7 @@ export class ConnectionManager {
 
             // Check for interruption (user started speaking again for continuation)
             if (connection.isProcessingInterrupted) {
-              console.log(
-                '[ConnectionManager] LLM stream interrupted for utterance continuation'
-              );
+              this.logger.debug('llm_stream_interrupted_for_continuation');
               wasInterrupted = true;
               break;
             }
@@ -275,8 +261,9 @@ export class ConnectionManager {
             const currentResponse = responseChunks.join('');
             if (currentResponse.trim()) {
               llmResponse = currentResponse;
-              console.log(
-                `[ConnectionManager] LLM Response complete: "${llmResponse.substring(0, 50)}..."`
+              this.logger.debug(
+                { responseSnippet: llmResponse.substring(0, 50) },
+                'llm_response_complete'
               );
               this.sendToClient({
                 type: 'llm_response_complete',
@@ -285,16 +272,14 @@ export class ConnectionManager {
               });
             }
           } else {
-            console.log(
-              '[ConnectionManager] LLM stream interrupted - skipping response complete'
-            );
+            this.logger.debug('llm_stream_interrupted_skipping_completion');
           }
         },
 
         // Handle TTS output stream
         TTSOutputStream: async (ttsData: unknown) => {
           const ttsStream = ttsData as GraphTypes.TTSOutputStream;
-          console.log('[ConnectionManager] Processing TTS stream...');
+          this.logger.debug('processing_tts_stream');
           let isFirstChunk = true;
           let wasInterrupted = false;
 
@@ -303,9 +288,7 @@ export class ConnectionManager {
 
             // Check for interruption (user started speaking again for continuation)
             if (connection.isProcessingInterrupted) {
-              console.log(
-                '[ConnectionManager] TTS interrupted for utterance continuation'
-              );
+              this.logger.debug('tts_interrupted_for_continuation');
               wasInterrupted = true;
               break;
             }
@@ -313,20 +296,24 @@ export class ConnectionManager {
             if (chunk.audio?.data) {
               // Log sample rate on first chunk
               if (isFirstChunk) {
-                console.log(
-                  `[ConnectionManager] TTS audio: sampleRate=${chunk.audio.sampleRate || TTS_SAMPLE_RATE}, bytes=${Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A'}`
+                this.logger.debug(
+                  {
+                    sampleRate: chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
+                    bytes: Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A',
+                  },
+                  'tts_audio_chunk'
                 );
               }
 
               // Convert audio to base64 for WebSocket transmission
-              // Use TTS_SAMPLE_RATE as fallback (not INPUT_SAMPLE_RATE which is for microphone input)
+              // Use ttsSampleRate as fallback (not inputSampleRate which is for microphone input)
               const audioResult = this.convertAudioToBase64(chunk.audio);
               if (audioResult) {
                 this.sendToClient({
                   type: 'audio_stream',
                   audio: audioResult.base64,
                   audioFormat: audioResult.format,
-                  sampleRate: chunk.audio.sampleRate || TTS_SAMPLE_RATE,
+                  sampleRate: chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
                   text: chunk.text || '',
                   isFirstChunk: isFirstChunk,
                   timestamp: Date.now(),
@@ -342,7 +329,7 @@ export class ConnectionManager {
           // Only send completion signals if not interrupted
           if (!wasInterrupted) {
             // Send completion signal
-            console.log('[ConnectionManager] TTS stream complete');
+            this.logger.debug('tts_stream_complete');
             this.sendToClient({
               type: 'audio_stream_complete',
               timestamp: Date.now(),
@@ -359,16 +346,14 @@ export class ConnectionManager {
             this.triggerFlashcardGeneration();
             this.triggerFeedbackGeneration();
           } else {
-            console.log(
-              '[ConnectionManager] TTS stream interrupted - skipping completion signals'
-            );
+            this.logger.debug('tts_interrupted_skipping_completion');
           }
         },
 
         // Handle errors
         error: async (error: unknown) => {
           const err = error as { message?: string };
-          console.error('[ConnectionManager] Graph error:', err);
+          this.logger.error({ err }, 'graph_error');
           if (!err.message?.includes('recognition produced no text')) {
             this.sendToClient({
               type: 'error',
@@ -380,14 +365,11 @@ export class ConnectionManager {
 
         // Default handler for unknown types
         default: (_data: unknown) => {
-          // console.log('[ConnectionManager] Unknown output type:', data);
+          // Ignore unknown output types
         },
       });
     } catch (error) {
-      console.error(
-        '[ConnectionManager] Error processing graph output:',
-        error
-      );
+      this.logger.error({ err: error }, 'graph_output_processing_error');
     }
   }
 
@@ -405,10 +387,10 @@ export class ConnectionManager {
       // MultimodalStreamManager will handle conversion when needed
       this.multimodalStreamManager.pushAudio({
         data: float32Data,
-        sampleRate: INPUT_SAMPLE_RATE,
+        sampleRate: serverConfig.audio.inputSampleRate,
       });
     } catch (error) {
-      console.error('[ConnectionManager] Error adding audio chunk:', error);
+      this.logger.error({ err: error }, 'audio_chunk_error');
     }
   }
 
@@ -416,13 +398,11 @@ export class ConnectionManager {
    * Handle speech detected event from AssemblyAI
    */
   private handleSpeechDetected(interactionId: string): void {
-    console.log(`[ConnectionManager] Speech detected: ${interactionId}`);
+    this.logger.debug({ interactionId }, 'speech_detected');
 
     // Check if we're currently processing a response - if so, this is a continuation
     if (this.isProcessingResponse && this.currentTranscript) {
-      console.log(
-        `[ConnectionManager] New speech during processing - interrupting for continuation`
-      );
+      this.logger.debug('new_speech_during_processing_interrupting');
       this.interruptForContinuation(this.currentTranscript);
 
       // Send interrupt signal with continuation reason so frontend discards partial response
@@ -470,8 +450,9 @@ export class ConnectionManager {
     if (connection) {
       connection.isProcessingInterrupted = true;
       connection.pendingTranscript = partialTranscript;
-      console.log(
-        `[ConnectionManager] Interrupting for continuation. Stored: "${partialTranscript.substring(0, 50)}..."`
+      this.logger.debug(
+        { transcriptSnippet: partialTranscript.substring(0, 50) },
+        'interrupting_for_continuation'
       );
 
       // Remove the last user message and any assistant response that was added
@@ -486,8 +467,9 @@ export class ConnectionManager {
       ) {
         const removed = messages.pop();
         removedCount++;
-        console.log(
-          `[ConnectionManager] Removed interrupted assistant message: "${removed?.content.substring(0, 50)}..."`
+        this.logger.debug(
+          { contentSnippet: removed?.content.substring(0, 50) },
+          'removed_interrupted_assistant_message'
         );
       }
 
@@ -498,8 +480,9 @@ export class ConnectionManager {
       ) {
         const removed = messages.pop();
         removedCount++;
-        console.log(
-          `[ConnectionManager] Removed partial user message: "${removed?.content.substring(0, 50)}..."`
+        this.logger.debug(
+          { contentSnippet: removed?.content.substring(0, 50) },
+          'removed_partial_user_message'
         );
       }
 
@@ -571,7 +554,7 @@ export class ConnectionManager {
       try {
         this.ws.send(JSON.stringify(message));
       } catch (error) {
-        console.error('[ConnectionManager] Error sending to client:', error);
+        this.logger.error({ err: error }, 'send_to_client_error');
       }
     }
   }
@@ -591,7 +574,7 @@ export class ConnectionManager {
     }));
 
     this.flashcardCallback(recentMessages).catch((error) => {
-      console.error('[ConnectionManager] Flashcard generation error:', error);
+      this.logger.error({ err: error }, 'flashcard_generation_trigger_error');
     });
   }
 
@@ -619,7 +602,7 @@ export class ConnectionManager {
 
     this.feedbackCallback(recentMessages, lastUserMessage.content).catch(
       (error) => {
-        console.error('[ConnectionManager] Feedback generation error:', error);
+        this.logger.error({ err: error }, 'feedback_generation_trigger_error');
       }
     );
   }
@@ -673,8 +656,9 @@ export class ConnectionManager {
   setLanguage(newLanguageCode: string): void {
     if (this.languageCode === newLanguageCode) return;
 
-    console.log(
-      `[ConnectionManager] Changing language from ${this.languageCode} to ${newLanguageCode}`
+    this.logger.info(
+      { from: this.languageCode, to: newLanguageCode },
+      'changing_language'
     );
 
     this.languageCode = newLanguageCode;
@@ -687,9 +671,7 @@ export class ConnectionManager {
       connection.state.voiceId = this.languageConfig.ttsConfig.speakerId;
     }
 
-    console.log(
-      `[ConnectionManager] Language changed to ${this.languageConfig.name}`
-    );
+    this.logger.info({ language: this.languageConfig.name }, 'language_changed');
   }
 
   /**
@@ -701,7 +683,7 @@ export class ConnectionManager {
       connection.state.messages = [];
       connection.state.interactionId = '';
     }
-    console.log('[ConnectionManager] Conversation reset');
+    this.logger.info('conversation_reset');
   }
 
   /**
@@ -713,8 +695,9 @@ export class ConnectionManager {
     const trimmedText = text.trim();
     if (!trimmedText) return;
 
-    console.log(
-      `[ConnectionManager] Sending text message: "${trimmedText.substring(0, 50)}..."`
+    this.logger.debug(
+      { textSnippet: trimmedText.substring(0, 50) },
+      'sending_text_message'
     );
     this.multimodalStreamManager.pushText(trimmedText);
   }
@@ -723,7 +706,7 @@ export class ConnectionManager {
    * Clean up resources
    */
   async destroy(): Promise<void> {
-    console.log(`[ConnectionManager] Destroying session ${this.sessionId}`);
+    this.logger.info('destroying_session');
     this.isDestroyed = true;
 
     // End the multimodal stream
@@ -735,6 +718,6 @@ export class ConnectionManager {
     // Remove from connections map
     delete this.connections[this.sessionId];
 
-    console.log(`[ConnectionManager] Session ${this.sessionId} destroyed`);
+    this.logger.info('session_destroyed');
   }
 }
diff --git a/backend/helpers/feedback-processor.ts b/backend/helpers/feedback-processor.ts
index b322f6e..0e8a49a 100644
--- a/backend/helpers/feedback-processor.ts
+++ b/backend/helpers/feedback-processor.ts
@@ -10,6 +10,7 @@ import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
+import { feedbackLogger as logger } from '../utils/logger.js';
 
 export interface ConversationMessage {
   role: string;
@@ -29,9 +30,7 @@ export class FeedbackProcessor {
     if (this.languageCode !== languageCode) {
       this.languageCode = languageCode;
       this.languageConfig = getLanguageConfig(languageCode);
-      console.log(
-        `FeedbackProcessor: Language changed to ${this.languageConfig.name}`
-      );
+      logger.info({ language: this.languageConfig.name }, 'language_changed');
     }
   }
 
@@ -61,9 +60,9 @@ export class FeedbackProcessor {
         };
         executionResult = await executor.start(input, executionContext);
       } catch (err) {
-        console.warn(
-          'Feedback executor.start with ExecutionContext failed, falling back without context:',
-          err
+        logger.warn(
+          { err },
+          'executor_start_with_context_failed_falling_back'
         );
         executionResult = await executor.start(input);
       }
@@ -76,7 +75,7 @@ export class FeedbackProcessor {
       const feedback = finalData as unknown as string;
       return feedback || '';
     } catch (error) {
-      console.error('Error generating feedback:', error);
+      logger.error({ err: error }, 'feedback_generation_error');
       return '';
     }
   }
diff --git a/backend/helpers/flashcard-processor.ts b/backend/helpers/flashcard-processor.ts
index 4825ff2..aa15b9e 100644
--- a/backend/helpers/flashcard-processor.ts
+++ b/backend/helpers/flashcard-processor.ts
@@ -8,6 +8,7 @@ import {
   getLanguageConfig,
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
+import { flashcardLogger as logger } from '../utils/logger.js';
 
 export interface Flashcard {
   id: string;
@@ -41,9 +42,7 @@ export class FlashcardProcessor {
     if (this.languageCode !== languageCode) {
       this.languageCode = languageCode;
       this.languageConfig = getLanguageConfig(languageCode);
-      console.log(
-        `FlashcardProcessor: Language changed to ${this.languageConfig.name}`
-      );
+      logger.info({ language: this.languageConfig.name }, 'language_changed');
     }
   }
 
@@ -83,7 +82,7 @@ export class FlashcardProcessor {
 
       return validFlashcards;
     } catch (error) {
-      console.error('Error generating flashcards:', error);
+      logger.error({ err: error }, 'flashcard_batch_generation_error');
       return [];
     }
   }
@@ -110,9 +109,9 @@ export class FlashcardProcessor {
         };
         executionResult = await executor.start(input, executionContext);
       } catch (err) {
-        console.warn(
-          'Flashcard executor.start with ExecutionContext failed, falling back without context:',
-          err
+        logger.warn(
+          { err },
+          'executor_start_with_context_failed_falling_back'
         );
         executionResult = await executor.start(input);
       }
@@ -148,7 +147,7 @@ export class FlashcardProcessor {
 
       return flashcard;
     } catch (error) {
-      console.error('Error generating single flashcard:', error);
+      logger.error({ err: error }, 'single_flashcard_generation_error');
       return {
         id: v4(),
         targetWord: '',
diff --git a/backend/helpers/multimodal-stream-manager.ts b/backend/helpers/multimodal-stream-manager.ts
index 4237029..95b701e 100644
--- a/backend/helpers/multimodal-stream-manager.ts
+++ b/backend/helpers/multimodal-stream-manager.ts
@@ -7,6 +7,9 @@
  */
 
 import { GraphTypes } from '@inworld/runtime/graph';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('MultimodalStreamManager');
 
 export interface AudioChunkInterface {
   data: number[] | Float32Array;
@@ -72,7 +75,7 @@ export class MultimodalStreamManager {
    * Mark the stream as ended
    */
   end(): void {
-    console.log('[MultimodalStreamManager] Ending stream');
+    logger.debug('stream_ending');
     this.ended = true;
 
     // Resolve all waiting consumers with done signal
@@ -92,7 +95,7 @@ export class MultimodalStreamManager {
     while (true) {
       // If stream ended and queue is empty, we're done
       if (this.ended && this.queue.length === 0) {
-        console.log('[MultimodalStreamManager] Stream iteration complete');
+        logger.debug('stream_iteration_complete');
         return;
       }
 
@@ -105,7 +108,7 @@ export class MultimodalStreamManager {
 
       // If stream ended but we just exhausted the queue, we're done
       if (this.ended) {
-        console.log('[MultimodalStreamManager] Stream iteration complete');
+        logger.debug('stream_iteration_complete');
         return;
       }
 
diff --git a/backend/server.ts b/backend/server.ts
index a04a635..d078365 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -39,6 +39,8 @@ import {
   getLanguageOptions,
   DEFAULT_LANGUAGE_CODE,
 } from './config/languages.js';
+import { serverConfig } from './config/server.js';
+import { serverLogger as logger } from './utils/logger.js';
 
 const app = express();
 const server = createServer(app);
@@ -47,8 +49,6 @@ const wss = new WebSocketServer({ server });
 // Add JSON parsing middleware
 app.use(express.json());
 
-const PORT = process.env.PORT || 3000;
-
 // ============================================================
 // Global State
 // ============================================================
@@ -80,8 +80,8 @@ try {
   if (telemetryApiKey) {
     telemetry.init({
       apiKey: telemetryApiKey,
-      appName: 'inworld-language-tutor',
-      appVersion: '1.0.0',
+      appName: serverConfig.telemetry.appName,
+      appVersion: serverConfig.telemetry.appVersion,
     });
 
     telemetry.configureMetric({
@@ -91,12 +91,10 @@ try {
       unit: 'clicks',
     });
   } else {
-    console.warn(
-      '[Telemetry] INWORLD_API_KEY not set. Metrics will be disabled.'
-    );
+    logger.warn('telemetry_disabled_no_api_key');
   }
-} catch (err) {
-  console.error('[Telemetry] Initialization failed:', err);
+} catch (error) {
+  logger.error({ err: error }, 'telemetry_init_failed');
 }
 
 // ============================================================
@@ -109,13 +107,13 @@ async function initializeGraph(): Promise<void> {
     throw new Error('ASSEMBLY_AI_API_KEY environment variable is required');
   }
 
-  console.log('[Server] Creating conversation graph...');
+  logger.info('creating_conversation_graph');
   graphWrapper = ConversationGraphWrapper.create({
     assemblyAIApiKey,
     connections,
     defaultLanguageCode: DEFAULT_LANGUAGE_CODE,
   });
-  console.log('[Server] Conversation graph created successfully');
+  logger.info('conversation_graph_created');
 }
 
 // ============================================================
@@ -124,13 +122,13 @@ async function initializeGraph(): Promise<void> {
 
 wss.on('connection', async (ws) => {
   if (!graphWrapper) {
-    console.error('[Server] Graph not initialized, rejecting connection');
+    logger.error('graph_not_initialized_rejecting_connection');
     ws.close(1011, 'Server not ready');
     return;
   }
 
-  const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  console.log(`[Server] WebSocket connection established: ${connectionId}`);
+  const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  logger.info({ connectionId }, 'websocket_connected');
 
   // Default language is Spanish
   const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
@@ -159,7 +157,7 @@ wss.on('connection', async (ws) => {
   // Set up flashcard generation callback
   connectionManager.setFlashcardCallback(async (messages) => {
     if (isShuttingDown) {
-      console.log('[Server] Skipping flashcard generation - shutting down');
+      logger.debug({ connectionId }, 'skipping_flashcard_generation_shutting_down');
       return;
     }
 
@@ -190,7 +188,7 @@ wss.on('connection', async (ws) => {
       }
     } catch (error) {
       if (!isShuttingDown) {
-        console.error('[Server] Error generating flashcards:', error);
+        logger.error({ err: error, connectionId }, 'flashcard_generation_error');
       }
     }
   });
@@ -198,7 +196,7 @@ wss.on('connection', async (ws) => {
   // Set up feedback generation callback
   connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
     if (isShuttingDown) {
-      console.log('[Server] Skipping feedback generation - shutting down');
+      logger.debug({ connectionId }, 'skipping_feedback_generation_shutting_down');
       return;
     }
 
@@ -231,7 +229,7 @@ wss.on('connection', async (ws) => {
       }
     } catch (error) {
       if (!isShuttingDown) {
-        console.error('[Server] Error generating feedback:', error);
+        logger.error({ err: error, connectionId }, 'feedback_generation_error');
       }
     }
   });
@@ -239,9 +237,9 @@ wss.on('connection', async (ws) => {
   // Start the graph for this connection
   try {
     await connectionManager.start();
-    console.log(`[Server] Graph started for connection ${connectionId}`);
+    logger.info({ connectionId }, 'graph_started');
   } catch (error) {
-    console.error(`[Server] Failed to start graph for ${connectionId}:`, error);
+    logger.error({ err: error, connectionId }, 'graph_start_failed');
     ws.close(1011, 'Failed to start audio processing');
     return;
   }
@@ -263,15 +261,16 @@ wss.on('connection', async (ws) => {
         // Reset all state
         connectionManager.reset();
         flashcardProcessors.get(connectionId)?.reset();
-        console.log(`[Server] Conversation restarted for ${connectionId}`);
+        logger.info({ connectionId }, 'conversation_restarted');
       } else if (message.type === 'set_language') {
         // Handle language change
         const newLanguageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
         const attrs = connectionAttributes.get(connectionId) || {};
 
         if (attrs.languageCode !== newLanguageCode) {
-          console.log(
-            `[Server] Language change: ${attrs.languageCode} -> ${newLanguageCode}`
+          logger.info(
+            { connectionId, from: attrs.languageCode, to: newLanguageCode },
+            'language_change'
           );
 
           attrs.languageCode = newLanguageCode;
@@ -299,7 +298,7 @@ wss.on('connection', async (ws) => {
             })
           );
 
-          console.log(`[Server] Language changed to ${languageConfig.name}`);
+          logger.info({ connectionId, language: languageConfig.name }, 'language_changed');
         }
       } else if (message.type === 'user_context') {
         const timezone = message.timezone || message.data?.timezone;
@@ -325,26 +324,26 @@ wss.on('connection', async (ws) => {
             timezone: attrs.timezone || '',
             languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
           });
-        } catch (err) {
-          console.error('[Server] Error recording flashcard click:', err);
+        } catch (error) {
+          logger.error({ err: error, connectionId }, 'flashcard_click_record_error');
         }
       } else if (message.type === 'text_message' && message.text) {
         // Handle text input (bypasses audio/STT)
         connectionManager.sendTextMessage(message.text);
       } else {
-        console.log('[Server] Received message type:', message.type);
+        logger.debug({ connectionId, messageType: message.type }, 'received_message');
       }
     } catch (error) {
-      console.error('[Server] Error processing message:', error);
+      logger.error({ err: error, connectionId }, 'message_processing_error');
     }
   });
 
   ws.on('error', (error) => {
-    console.error(`[Server] WebSocket error for ${connectionId}:`, error);
+    logger.error({ err: error, connectionId }, 'websocket_error');
   });
 
   ws.on('close', async () => {
-    console.log(`[Server] WebSocket closed: ${connectionId}`);
+    logger.info({ connectionId }, 'websocket_closed');
 
     // Clean up connection manager
     const manager = connectionManagers.get(connectionId);
@@ -352,7 +351,7 @@ wss.on('connection', async (ws) => {
       try {
         await manager.destroy();
       } catch (error) {
-        console.error(`[Server] Error destroying connection manager:`, error);
+        logger.error({ err: error, connectionId }, 'connection_manager_destroy_error');
       }
       connectionManagers.delete(connectionId);
     }
@@ -399,7 +398,7 @@ app.post('/api/export-anki', async (req, res) => {
     );
     res.send(apkgBuffer);
   } catch (error) {
-    console.error('[Server] Error exporting Anki deck:', error);
+    logger.error({ err: error }, 'anki_export_error');
     res.status(500).json({ error: 'Failed to export Anki deck' });
   }
 });
@@ -410,7 +409,7 @@ app.get('/api/languages', (_req, res) => {
     const languages = getLanguageOptions();
     res.json({ languages, defaultLanguage: DEFAULT_LANGUAGE_CODE });
   } catch (error) {
-    console.error('[Server] Error getting languages:', error);
+    logger.error({ err: error }, 'get_languages_error');
     res.status(500).json({ error: 'Failed to get languages' });
   }
 });
@@ -433,12 +432,12 @@ app.use(express.static(finalStaticPath));
 async function startServer(): Promise<void> {
   try {
     await initializeGraph();
-    server.listen(PORT, () => {
-      console.log(`[Server] Running on port ${PORT}`);
-      console.log(`[Server] Using Inworld Runtime 0.9 with AssemblyAI STT`);
+    server.listen(serverConfig.port, () => {
+      logger.info({ port: serverConfig.port }, 'server_started');
+      logger.info('using_inworld_runtime_0.9_with_assemblyai_stt');
     });
   } catch (error) {
-    console.error('[Server] Failed to start:', error);
+    logger.fatal({ err: error }, 'server_start_failed');
     process.exit(1);
   }
 }
@@ -453,13 +452,11 @@ async function gracefulShutdown(): Promise<void> {
   if (isShuttingDown) return;
   isShuttingDown = true;
 
-  console.log('[Server] Shutting down gracefully...');
+  logger.info('shutdown_initiated');
 
   try {
     // Close all WebSocket connections
-    console.log(
-      `[Server] Closing ${wss.clients.size} WebSocket connections...`
-    );
+    logger.info({ connectionCount: wss.clients.size }, 'closing_websocket_connections');
     wss.clients.forEach((ws) => {
       if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
         ws.close();
@@ -479,14 +476,14 @@ async function gracefulShutdown(): Promise<void> {
     }
 
     server.close(() => {
-      console.log('[Server] HTTP server closed');
+      logger.info('http_server_closed');
     });
 
     stopInworldRuntime()
-      .then(() => console.log('[Server] Inworld Runtime stopped'))
+      .then(() => logger.info('inworld_runtime_stopped'))
       .catch(() => {});
 
-    console.log('[Server] Shutdown complete');
+    logger.info('shutdown_complete');
   } catch {
     // Ignore errors during shutdown
   }
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 5f5aad0..781c43b 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -74,9 +74,3 @@ export interface InteractionInfo {
   interactionComplete: boolean;
 }
 
-/**
- * Config constants
- */
-export const INPUT_SAMPLE_RATE = 16000;
-// Inworld TTS typically outputs at 22050Hz
-export const TTS_SAMPLE_RATE = 22050;
diff --git a/backend/types/settings.ts b/backend/types/settings.ts
deleted file mode 100644
index 4f8e7b6..0000000
--- a/backend/types/settings.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Maps eagerness levels to AssemblyAI turn detection settings
- * Based on AssemblyAI's recommended configurations for different use cases
- *
- * @see https://www.assemblyai.com/docs/speech-to-text/universal-streaming/turn-detection
- */
-
-export interface AssemblyAITurnDetectionSettings {
-  endOfTurnConfidenceThreshold: number;
-  minEndOfTurnSilenceWhenConfident: number;
-  maxTurnSilence: number;
-  description: string;
-}
-
-/**
- * Get AssemblyAI turn detection settings for a given eagerness level
- *
- * AssemblyAI's turn detection model uses:
- * - Semantic detection: Neural network predicts when speech naturally ends
- * - Acoustic detection: Traditional silence-based detection as backup (VAD)
- *
- * @param eagerness - The eagerness level ('low' | 'medium' | 'high')
- * @returns AssemblyAI turn detection settings including threshold values and description
- */
-export function getAssemblyAISettingsForEagerness(
-  eagerness: 'low' | 'medium' | 'high' = 'low'
-): AssemblyAITurnDetectionSettings {
-  switch (eagerness) {
-    case 'high': // Aggressive - per AssemblyAI docs
-      // Use cases: Agent Assist, IVR replacements, Retail/E-commerce, Telecom
-      return {
-        endOfTurnConfidenceThreshold: 0.4,
-        minEndOfTurnSilenceWhenConfident: 160,
-        maxTurnSilence: 400,
-        description:
-          'Aggressive - Quick responses for rapid back-and-forth (IVR, order confirmations)',
-      };
-    case 'medium': // Balanced - per AssemblyAI docs
-      // Use cases: Customer Support, Tech Support, Financial Services, Travel
-      return {
-        endOfTurnConfidenceThreshold: 0.4,
-        minEndOfTurnSilenceWhenConfident: 400,
-        maxTurnSilence: 1280,
-        description:
-          'Balanced - Natural middle ground for most conversational turns',
-      };
-    case 'low': // Conservative - per AssemblyAI docs
-      // Use cases: Healthcare, Mental Health, Sales, Legal, LANGUAGE LEARNING
-      return {
-        endOfTurnConfidenceThreshold: 0.7,
-        minEndOfTurnSilenceWhenConfident: 800,
-        maxTurnSilence: 3600,
-        description:
-          'Conservative - Patient, allows thinking pauses (Language Learning, Healthcare)',
-      };
-  }
-}
diff --git a/backend/utils/logger.ts b/backend/utils/logger.ts
new file mode 100644
index 0000000..782e413
--- /dev/null
+++ b/backend/utils/logger.ts
@@ -0,0 +1,55 @@
+/**
+ * Structured Logging with Pino
+ *
+ * Provides a centralized logging system with:
+ * - Log levels (trace, debug, info, warn, error, fatal)
+ * - Structured JSON output in production
+ * - Pretty-printed output in development
+ * - Child loggers with context (module, sessionId)
+ */
+
+import pino from 'pino';
+
+const isDevelopment = process.env.NODE_ENV !== 'production';
+
+/**
+ * Root logger instance
+ * Configure LOG_LEVEL env var to change verbosity (default: 'info')
+ */
+export const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  transport: isDevelopment
+    ? {
+        target: 'pino-pretty',
+        options: {
+          colorize: true,
+          translateTime: 'SYS:standard',
+          ignore: 'pid,hostname',
+        },
+      }
+    : undefined,
+});
+
+/**
+ * Create a child logger for a specific module
+ * @param module - Module name (e.g., 'Server', 'ConnectionManager')
+ */
+export function createLogger(module: string): pino.Logger {
+  return logger.child({ module });
+}
+
+/**
+ * Create a session-scoped logger with module and sessionId context
+ * @param module - Module name
+ * @param sessionId - Session/connection identifier
+ */
+export function createSessionLogger(module: string, sessionId: string): pino.Logger {
+  return logger.child({ module, sessionId });
+}
+
+// Pre-created module loggers for common components
+export const serverLogger = createLogger('Server');
+export const graphLogger = createLogger('Graph');
+export const connectionLogger = createLogger('ConnectionManager');
+export const flashcardLogger = createLogger('FlashcardProcessor');
+export const feedbackLogger = createLogger('FeedbackProcessor');
diff --git a/package-lock.json b/package-lock.json
index d94e982..482c25f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,6 +13,7 @@
         "anki-apkg-export": "^4.0.3",
         "dotenv": "^17.2.1",
         "express": "^4.19.2",
+        "pino": "^10.1.0",
         "uuid": "^11.1.0",
         "ws": "^8.18.0"
       },
@@ -26,6 +27,7 @@
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-prettier": "^5.1.3",
         "nodemon": "^3.1.10",
+        "pino-pretty": "^13.1.3",
         "prettier": "^3.2.5",
         "tsx": "^4.7.0",
         "typescript": "^5.3.3",
@@ -814,6 +816,12 @@
         "node": ">= 8"
       }
     },
+    "node_modules/@pinojs/redact": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz",
+      "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
+      "license": "MIT"
+    },
     "node_modules/@pkgr/core": {
       "version": "0.2.9",
       "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz",
@@ -1580,6 +1588,15 @@
       "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
       "license": "MIT"
     },
+    "node_modules/atomic-sleep": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz",
+      "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
@@ -1918,6 +1935,13 @@
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
       "license": "MIT"
     },
+    "node_modules/colorette": {
+      "version": "2.0.20",
+      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
+      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/combined-stream": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
@@ -2009,6 +2033,16 @@
         "node": "*"
       }
     },
+    "node_modules/dateformat": {
+      "version": "4.6.3",
+      "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-4.6.3.tgz",
+      "integrity": "sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/debug": {
       "version": "2.6.9",
       "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
@@ -2646,6 +2680,13 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/fast-copy": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/fast-copy/-/fast-copy-4.0.2.tgz",
+      "integrity": "sha512-ybA6PDXIXOXivLJK/z9e+Otk7ve13I4ckBvGO5I2RRmBU1gMHLVDJYEuJYhGwez7YNlYji2M2DvVU+a9mSFDlw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -2690,6 +2731,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/fast-safe-stringify": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
+      "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/fast-uri": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
@@ -3119,6 +3167,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/help-me": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/help-me/-/help-me-5.0.0.tgz",
+      "integrity": "sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/http-errors": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
@@ -3342,6 +3397,16 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/joycon": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
+      "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/js-yaml": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
@@ -3582,6 +3647,16 @@
         "node": "*"
       }
     },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
@@ -3738,6 +3813,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/on-exit-leak-free": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
+      "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/on-finished": {
       "version": "2.4.1",
       "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
@@ -3912,6 +3996,91 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/pino": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/pino/-/pino-10.1.0.tgz",
+      "integrity": "sha512-0zZC2ygfdqvqK8zJIr1e+wT1T/L+LF6qvqvbzEQ6tiMAoTqEVK9a1K3YRu8HEUvGEvNqZyPJTtb2sNIoTkB83w==",
+      "license": "MIT",
+      "dependencies": {
+        "@pinojs/redact": "^0.4.0",
+        "atomic-sleep": "^1.0.0",
+        "on-exit-leak-free": "^2.1.0",
+        "pino-abstract-transport": "^2.0.0",
+        "pino-std-serializers": "^7.0.0",
+        "process-warning": "^5.0.0",
+        "quick-format-unescaped": "^4.0.3",
+        "real-require": "^0.2.0",
+        "safe-stable-stringify": "^2.3.1",
+        "sonic-boom": "^4.0.1",
+        "thread-stream": "^3.0.0"
+      },
+      "bin": {
+        "pino": "bin.js"
+      }
+    },
+    "node_modules/pino-abstract-transport": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz",
+      "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.0.0"
+      }
+    },
+    "node_modules/pino-pretty": {
+      "version": "13.1.3",
+      "resolved": "https://registry.npmjs.org/pino-pretty/-/pino-pretty-13.1.3.tgz",
+      "integrity": "sha512-ttXRkkOz6WWC95KeY9+xxWL6AtImwbyMHrL1mSwqwW9u+vLp/WIElvHvCSDg0xO/Dzrggz1zv3rN5ovTRVowKg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "colorette": "^2.0.7",
+        "dateformat": "^4.6.3",
+        "fast-copy": "^4.0.0",
+        "fast-safe-stringify": "^2.1.1",
+        "help-me": "^5.0.0",
+        "joycon": "^3.1.1",
+        "minimist": "^1.2.6",
+        "on-exit-leak-free": "^2.1.0",
+        "pino-abstract-transport": "^3.0.0",
+        "pump": "^3.0.0",
+        "secure-json-parse": "^4.0.0",
+        "sonic-boom": "^4.0.1",
+        "strip-json-comments": "^5.0.2"
+      },
+      "bin": {
+        "pino-pretty": "bin.js"
+      }
+    },
+    "node_modules/pino-pretty/node_modules/pino-abstract-transport": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-3.0.0.tgz",
+      "integrity": "sha512-wlfUczU+n7Hy/Ha5j9a/gZNy7We5+cXp8YL+X+PG8S0KXxw7n/JXA3c46Y0zQznIJ83URJiwy7Lh56WLokNuxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.0.0"
+      }
+    },
+    "node_modules/pino-pretty/node_modules/strip-json-comments": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.3.tgz",
+      "integrity": "sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/pino-std-serializers": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz",
+      "integrity": "sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==",
+      "license": "MIT"
+    },
     "node_modules/possible-typed-array-names": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
@@ -3966,6 +4135,22 @@
       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "license": "MIT"
     },
+    "node_modules/process-warning": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz",
+      "integrity": "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/protobufjs": {
       "version": "7.5.4",
       "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
@@ -4010,6 +4195,17 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/pump": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -4056,6 +4252,12 @@
       ],
       "license": "MIT"
     },
+    "node_modules/quick-format-unescaped": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz",
+      "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==",
+      "license": "MIT"
+    },
     "node_modules/range-parser": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
@@ -4114,6 +4316,15 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/real-require": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz",
+      "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12.13.0"
+      }
+    },
     "node_modules/require-from-string": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
@@ -4198,12 +4409,38 @@
       ],
       "license": "MIT"
     },
+    "node_modules/safe-stable-stringify": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
+      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
+    "node_modules/secure-json-parse": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-4.1.0.tgz",
+      "integrity": "sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
     "node_modules/seek-bzip": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.6.tgz",
@@ -4434,6 +4671,24 @@
         "node": ">=10"
       }
     },
+    "node_modules/sonic-boom": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.0.tgz",
+      "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==",
+      "license": "MIT",
+      "dependencies": {
+        "atomic-sleep": "^1.0.0"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
     "node_modules/sql.js": {
       "version": "0.5.0",
       "resolved": "https://registry.npmjs.org/sql.js/-/sql.js-0.5.0.tgz",
@@ -4533,6 +4788,15 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/thread-stream": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
+      "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==",
+      "license": "MIT",
+      "dependencies": {
+        "real-require": "^0.2.0"
+      }
+    },
     "node_modules/through": {
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
diff --git a/package.json b/package.json
index 19fbda3..0164f84 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "nodemon": "^3.1.10",
+    "pino-pretty": "^13.1.3",
     "prettier": "^3.2.5",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
@@ -47,6 +48,7 @@
     "anki-apkg-export": "^4.0.3",
     "dotenv": "^17.2.1",
     "express": "^4.19.2",
+    "pino": "^10.1.0",
     "uuid": "^11.1.0",
     "ws": "^8.18.0"
   }

From c30ff71db9d92f004f9aead3210d85b8b7408975 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 11:13:42 -0800
Subject: [PATCH 17/49] added graph export for registration

---
 README.md                                     |  14 +-
 backend/config/languages.ts                   |  36 ---
 .../configs/flashcard-generation-graph.json   |  95 ++++++
 .../lang-learning-conversation-graph.json     | 279 ++++++++++++++++++
 .../configs/response-feedback-graph.json      |  95 ++++++
 .../nodes/dialog-prompt-builder-node.ts       |   1 -
 backend/graphs/response-feedback-graph.ts     |  20 +-
 backend/helpers/feedback-processor.ts         |   8 +-
 backend/helpers/prompt-templates.ts           |  82 +----
 backend/prompts/conversation.njk              |  27 ++
 backend/prompts/flashcard.njk                 |  35 +++
 backend/prompts/response-feedback.njk         |  17 ++
 backend/server.ts                             |  26 ++
 13 files changed, 609 insertions(+), 126 deletions(-)
 create mode 100644 backend/graphs/configs/flashcard-generation-graph.json
 create mode 100644 backend/graphs/configs/lang-learning-conversation-graph.json
 create mode 100644 backend/graphs/configs/response-feedback-graph.json
 create mode 100644 backend/prompts/conversation.njk
 create mode 100644 backend/prompts/flashcard.njk
 create mode 100644 backend/prompts/response-feedback.njk

diff --git a/README.md b/README.md
index 976007e..3654fa0 100644
--- a/README.md
+++ b/README.md
@@ -84,9 +84,11 @@ language-learning-node/
 │   │   ├── llm.ts            # LLM model configuration
 │   │   └── server.ts         # Server and audio settings
 │   ├── graphs/               # Graph definitions
+│   │   ├── configs/          # Auto-exported graph JSON configs
 │   │   ├── nodes/            # Graph node implementations
 │   │   ├── conversation-graph.ts
-│   │   └── flashcard-graph.ts
+│   │   ├── flashcard-graph.ts
+│   │   └── response-feedback-graph.ts
 │   ├── helpers/              # Helper utilities
 │   │   ├── anki-exporter.ts
 │   │   ├── audio-buffer.ts
@@ -113,6 +115,16 @@ language-learning-node/
 └── LICENSE                   # MIT License
 ```
 
+## Graph Registration
+
+On server startup, graph JSON configurations are automatically exported to `backend/graphs/configs/`. To register graphs with the Inworld Portal for use with [Experiments](https://docs.inworld.ai/docs/node/guides/experiments):
+
+1. Start the server (`npm run dev`)
+2. Find the exported JSON files in `backend/graphs/configs/`
+3. In the [Inworld Portal](https://platform.inworld.ai/), go to **Register Graph**
+4. Enter the graph ID (e.g., `flashcard-generation-graph`)
+5. Click **Create Variant** and upload the corresponding JSON file
+
 ## Troubleshooting
 
 **Bug Reports**: [GitHub Issues](https://github.com/inworld-ai/language-learning-node/issues)
diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index a1f5663..a0b2f68 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -46,9 +46,6 @@ export interface LanguageConfig {
 
   // Example conversation topics specific to this language's culture
   exampleTopics: string[];
-
-  // Language-specific instructions for the LLM (written in English, about teaching this language)
-  promptInstructions: string;
 }
 
 /**
@@ -88,11 +85,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'American idioms and slang',
       'travel across the United States',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in English
-- Explain common idioms and phrasal verbs when they come up naturally
-- Help with pronunciation of tricky English sounds
-- Vary complexity based on the user's level`,
   },
 
   es: {
@@ -122,10 +114,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'the concept of brunch across cultures',
       'Balkan travel',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in Spanish
-- Use natural Mexican Spanish expressions when appropriate
-- Vary complexity based on the user's level`,
   },
 
   fr: {
@@ -156,12 +144,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'travel in Provence and the French Riviera',
       'French music from Édith Piaf to modern artists',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in French
-- Pay attention to gender agreement and verb conjugation corrections
-- Explain the nuances between formal (vous) and informal (tu) when relevant
-- Share cultural context about French expressions and idioms
-- Mention pronunciation tips for tricky French sounds`,
   },
 
   de: {
@@ -192,12 +174,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'traveling through Bavaria and the Alps',
       'German literature from Goethe to modern authors',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in German
-- Help with noun genders (der, die, das) and case endings
-- Explain compound word formation when relevant
-- Share cultural context about German expressions
-- Help with word order in main and subordinate clauses`,
   },
 
   it: {
@@ -228,12 +204,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'fashion and design in Milan',
       'Italian music from opera to modern pop',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in Italian
-- Help with verb conjugations and tenses
-- Explain the use of formal (Lei) vs informal (tu) when relevant
-- Share cultural context about Italian expressions and gestures
-- Mention regional variations when appropriate`,
   },
 
   pt: {
@@ -264,12 +234,6 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
       'football (soccer) culture',
       'the Amazon and Brazilian nature',
     ],
-    promptInstructions: `
-- Gently correct the user if they make mistakes in Portuguese
-- Use natural Brazilian Portuguese expressions when appropriate
-- Explain differences between Brazilian and European Portuguese when relevant
-- Help with verb conjugations and the subjunctive mood
-- Share cultural context about Brazilian expressions and slang`,
   },
 };
 
diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/graphs/configs/flashcard-generation-graph.json
new file mode 100644
index 0000000..7cb5d7b
--- /dev/null
+++ b/backend/graphs/configs/flashcard-generation-graph.json
@@ -0,0 +1,95 @@
+{
+  "schema_version": "1.2.2",
+  "main": {
+    "id": "flashcard-generation-graph",
+    "nodes": [
+      {
+        "type": "FlashcardPromptBuilderNodeType",
+        "id": "flashcard-prompt-builder",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "TextToChatRequestNodeType",
+        "id": "text-to-chat-request",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "id": "llm_node",
+        "type": "LLMChatNode",
+        "execution_config": {
+          "type": "LLMChatNodeExecutionConfig",
+          "properties": {
+            "llm_component_id": "llm_node_llm_component",
+            "text_generation_config": {
+              "max_new_tokens": 2500,
+              "max_prompt_length": 100,
+              "temperature": 1,
+              "top_p": 1,
+              "repetition_penalty": 1,
+              "frequency_penalty": 0,
+              "presence_penalty": 0
+            },
+            "stream": false,
+            "report_to_client": false,
+            "response_format": "text"
+          }
+        }
+      },
+      {
+        "type": "FlashcardParserNodeType",
+        "id": "flashcard-parser",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      }
+    ],
+    "edges": [
+      {
+        "from_node": "flashcard-prompt-builder",
+        "to_node": "text-to-chat-request"
+      },
+      {
+        "from_node": "text-to-chat-request",
+        "to_node": "llm_node"
+      },
+      {
+        "from_node": "llm_node",
+        "to_node": "flashcard-parser"
+      }
+    ],
+    "end_nodes": [
+      "flashcard-parser"
+    ],
+    "start_nodes": [
+      "flashcard-prompt-builder"
+    ]
+  },
+  "components": [
+    {
+      "id": "llm_node_llm_component",
+      "type": "LLMInterface",
+      "creation_config": {
+        "type": "RemoteLLMConfig",
+        "properties": {
+          "provider": "openai",
+          "model_name": "gpt-4.1-nano",
+          "default_config": {},
+          "api_key": "{{INWORLD_API_KEY}}"
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
new file mode 100644
index 0000000..59ef59d
--- /dev/null
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -0,0 +1,279 @@
+{
+  "schema_version": "1.2.2",
+  "main": {
+    "id": "lang-learning-conversation-graph",
+    "nodes": [
+      {
+        "id": "audio-input-proxy-lang-learning",
+        "type": "ProxyNode",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "AssemblyAISTTWebSocketNodeType",
+        "id": "assembly-ai-stt-ws-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "TranscriptExtractorNodeType",
+        "id": "transcript-extractor-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": true
+          }
+        }
+      },
+      {
+        "type": "InteractionQueueNodeType",
+        "id": "interaction-queue-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "TextInputNodeType",
+        "id": "text-input-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": true
+          }
+        }
+      },
+      {
+        "type": "DialogPromptBuilderNodeType",
+        "id": "dialog-prompt-builder-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "id": "llm-node-lang-learning",
+        "type": "LLMChatNode",
+        "execution_config": {
+          "type": "LLMChatNodeExecutionConfig",
+          "properties": {
+            "llm_component_id": "llm-node-lang-learning_llm_component",
+            "text_generation_config": {
+              "max_new_tokens": 250,
+              "max_prompt_length": 2000,
+              "temperature": 1,
+              "top_p": 1,
+              "repetition_penalty": 1,
+              "frequency_penalty": 0,
+              "presence_penalty": 0
+            },
+            "stream": true,
+            "report_to_client": true,
+            "response_format": "text"
+          }
+        }
+      },
+      {
+        "id": "text-chunking-node-lang-learning",
+        "type": "TextChunkingNode",
+        "execution_config": {
+          "type": "TextChunkingNodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "id": "text-aggregator-node-lang-learning",
+        "type": "TextAggregatorNode",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "TTSRequestBuilderNodeType",
+        "id": "tts-request-builder-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "id": "tts-node-lang-learning",
+        "type": "TTSNode",
+        "execution_config": {
+          "type": "TTSNodeExecutionConfig",
+          "properties": {
+            "tts_component_id": "tts-node-lang-learning_tts_component",
+            "voice": {
+              "id": "Diego",
+              "language_code": "es-MX"
+            },
+            "synthesis_config": {
+              "type": "inworld",
+              "config": {
+                "model_id": "inworld-tts-1",
+                "inference": {
+                  "speaking_rate": 1.1,
+                  "temperature": 1.1
+                },
+                "postprocessing": {
+                  "sample_rate": 22050
+                }
+              }
+            },
+            "report_to_client": true
+          }
+        }
+      },
+      {
+        "type": "StateUpdateNodeType",
+        "id": "state-update-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": true
+          }
+        }
+      }
+    ],
+    "edges": [
+      {
+        "from_node": "audio-input-proxy-lang-learning",
+        "to_node": "assembly-ai-stt-ws-node-lang-learning"
+      },
+      {
+        "from_node": "assembly-ai-stt-ws-node-lang-learning",
+        "to_node": "assembly-ai-stt-ws-node-lang-learning",
+        "condition_id": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-assembly-ai-stt-ws-node-lang-learning",
+        "optional": true,
+        "loop": true
+      },
+      {
+        "from_node": "assembly-ai-stt-ws-node-lang-learning",
+        "to_node": "transcript-extractor-node-lang-learning",
+        "condition_id": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-transcript-extractor-node-lang-learning"
+      },
+      {
+        "from_node": "transcript-extractor-node-lang-learning",
+        "to_node": "interaction-queue-node-lang-learning"
+      },
+      {
+        "from_node": "interaction-queue-node-lang-learning",
+        "to_node": "text-input-node-lang-learning",
+        "condition_id": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
+      },
+      {
+        "from_node": "text-input-node-lang-learning",
+        "to_node": "dialog-prompt-builder-node-lang-learning"
+      },
+      {
+        "from_node": "text-input-node-lang-learning",
+        "to_node": "tts-request-builder-node-lang-learning"
+      },
+      {
+        "from_node": "dialog-prompt-builder-node-lang-learning",
+        "to_node": "llm-node-lang-learning"
+      },
+      {
+        "from_node": "llm-node-lang-learning",
+        "to_node": "text-chunking-node-lang-learning"
+      },
+      {
+        "from_node": "llm-node-lang-learning",
+        "to_node": "text-aggregator-node-lang-learning"
+      },
+      {
+        "from_node": "text-chunking-node-lang-learning",
+        "to_node": "tts-request-builder-node-lang-learning"
+      },
+      {
+        "from_node": "tts-request-builder-node-lang-learning",
+        "to_node": "tts-node-lang-learning"
+      },
+      {
+        "from_node": "text-aggregator-node-lang-learning",
+        "to_node": "state-update-node-lang-learning"
+      },
+      {
+        "from_node": "state-update-node-lang-learning",
+        "to_node": "interaction-queue-node-lang-learning",
+        "optional": true,
+        "loop": true
+      }
+    ],
+    "end_nodes": [
+      "tts-node-lang-learning"
+    ],
+    "start_nodes": [
+      "audio-input-proxy-lang-learning"
+    ]
+  },
+  "components": [
+    {
+      "id": "llm-node-lang-learning_llm_component",
+      "type": "LLMInterface",
+      "creation_config": {
+        "type": "RemoteLLMConfig",
+        "properties": {
+          "provider": "openai",
+          "model_name": "gpt-4.1-nano",
+          "default_config": {},
+          "api_key": "{{INWORLD_API_KEY}}"
+        }
+      }
+    },
+    {
+      "id": "tts-node-lang-learning_tts_component",
+      "type": "TTSInterface",
+      "creation_config": {
+        "type": "RemoteTTSConfig",
+        "properties": {
+          "synthesis_config": {
+            "type": "inworld",
+            "config": {
+              "model_id": "inworld-tts-1",
+              "inference": {
+                "speaking_rate": 1.1,
+                "temperature": 1.1
+              },
+              "postprocessing": {
+                "sample_rate": 22050
+              }
+            }
+          },
+          "api_key": "{{INWORLD_API_KEY}}"
+        }
+      }
+    },
+    {
+      "id": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-assembly-ai-stt-ws-node-lang-learning",
+      "type": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-assembly-ai-stt-ws-node-lang-learning"
+    },
+    {
+      "id": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-transcript-extractor-node-lang-learning",
+      "type": "custom-condition-from-assembly-ai-stt-ws-node-lang-learning-to-transcript-extractor-node-lang-learning"
+    },
+    {
+      "id": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning",
+      "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/graphs/configs/response-feedback-graph.json
new file mode 100644
index 0000000..978b019
--- /dev/null
+++ b/backend/graphs/configs/response-feedback-graph.json
@@ -0,0 +1,95 @@
+{
+  "schema_version": "1.2.2",
+  "main": {
+    "id": "response-feedback-graph",
+    "nodes": [
+      {
+        "type": "FeedbackPromptBuilderNodeType",
+        "id": "feedback-prompt-builder",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "type": "TextToChatRequestNodeType",
+        "id": "text-to-chat-request",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
+      {
+        "id": "llm-node",
+        "type": "LLMChatNode",
+        "execution_config": {
+          "type": "LLMChatNodeExecutionConfig",
+          "properties": {
+            "llm_component_id": "llm-node_llm_component",
+            "text_generation_config": {
+              "max_new_tokens": 100,
+              "max_prompt_length": 2000,
+              "temperature": 0.7,
+              "top_p": 1,
+              "repetition_penalty": 1,
+              "frequency_penalty": 0,
+              "presence_penalty": 0
+            },
+            "stream": false,
+            "report_to_client": false,
+            "response_format": "text"
+          }
+        }
+      },
+      {
+        "type": "FeedbackExtractorNodeType",
+        "id": "feedback-extractor",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      }
+    ],
+    "edges": [
+      {
+        "from_node": "feedback-prompt-builder",
+        "to_node": "text-to-chat-request"
+      },
+      {
+        "from_node": "text-to-chat-request",
+        "to_node": "llm-node"
+      },
+      {
+        "from_node": "llm-node",
+        "to_node": "feedback-extractor"
+      }
+    ],
+    "end_nodes": [
+      "feedback-extractor"
+    ],
+    "start_nodes": [
+      "feedback-prompt-builder"
+    ]
+  },
+  "components": [
+    {
+      "id": "llm-node_llm_component",
+      "type": "LLMInterface",
+      "creation_config": {
+        "type": "RemoteLLMConfig",
+        "properties": {
+          "provider": "openai",
+          "model_name": "gpt-4.1-nano",
+          "default_config": {},
+          "api_key": "{{INWORLD_API_KEY}}"
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index 1127a73..fde1958 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -47,7 +47,6 @@ export class DialogPromptBuilderNode extends CustomNode {
       teacher_name: langConfig.teacherPersona.name,
       teacher_description: langConfig.teacherPersona.description,
       example_topics: langConfig.exampleTopics.join(', '),
-      language_instructions: langConfig.promptInstructions,
     };
 
     // Get all messages except the last user message (that's our current_input)
diff --git a/backend/graphs/response-feedback-graph.ts b/backend/graphs/response-feedback-graph.ts
index 55c8365..a81d7c9 100644
--- a/backend/graphs/response-feedback-graph.ts
+++ b/backend/graphs/response-feedback-graph.ts
@@ -11,6 +11,7 @@ import { GraphTypes } from '@inworld/runtime/common';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { llmConfig } from '../config/llm.js';
 import { feedbackLogger as logger } from '../utils/logger.js';
+import { responseFeedbackPromptTemplate } from '../helpers/prompt-templates.js';
 
 export interface ResponseFeedbackInput {
   messages: Array<{ role: string; content: string }>;
@@ -18,25 +19,6 @@ export interface ResponseFeedbackInput {
   targetLanguage: string;
 }
 
-const responseFeedbackPromptTemplate = `
-You are a {{targetLanguage}} language tutor assistant. Your task is to analyze the student's most recent utterance and provide brief, helpful feedback.
-
-## Conversation so far:
-{% for message in messages %}
-{{ message.role }}: {{ message.content }}
-{% endfor %}
-
-## Student's last utterance:
-{{ currentTranscript }}
-
-## Instructions:
-- If the student made any grammar, vocabulary, or pronunciation errors in their {{targetLanguage}}, offer a gentle correction
-- If the student's response was good, offer a brief word of encouragement or a small tip to improve
-- Keep your feedback to exactly ONE sentence in English
-- Be encouraging and constructive
-
-Your feedback (one sentence in English):`.trim();
-
 class FeedbackPromptBuilderNode extends CustomNode {
   async process(_context: ProcessContext, input: ResponseFeedbackInput) {
     const builder = await PromptBuilder.create(responseFeedbackPromptTemplate);
diff --git a/backend/helpers/feedback-processor.ts b/backend/helpers/feedback-processor.ts
index 0e8a49a..e67a612 100644
--- a/backend/helpers/feedback-processor.ts
+++ b/backend/helpers/feedback-processor.ts
@@ -45,9 +45,15 @@ export class FeedbackProcessor {
   ): Promise<string> {
     const executor = getResponseFeedbackGraph();
 
+    // Remove the last assistant message so conversation ends with user's utterance
+    let conversationMessages = messages;
+    if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+      conversationMessages = messages.slice(0, -1);
+    }
+
     try {
       const input: ResponseFeedbackInput = {
-        messages: messages,
+        messages: conversationMessages,
         currentTranscript: currentTranscript,
         targetLanguage: this.languageConfig.name,
       };
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index 14d2940..13b56af 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -1,82 +1,28 @@
 /**
  * Prompt Templates for Multi-Language Support
  *
+ * Templates are loaded from .njk files in the /prompts folder.
  * All templates use Jinja2-style variables that are injected at runtime:
  * - {{target_language}} - English name of target language (e.g., "Spanish")
  * - {{target_language_native}} - Native name (e.g., "Español")
  * - {{teacher_name}} - Teacher persona name
  * - {{teacher_description}} - Full teacher persona description
  * - {{example_topics}} - Comma-separated list of conversation topics
- * - {{language_instructions}} - Language-specific teaching instructions
  */
 
-export const conversationTemplate = `
+import { readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 
-# Context
-- You are {{teacher_name}}, {{teacher_description}}.
-- You are embedded in a {{target_language}} learning app called 'Inworld Language Tutor', which is a demonstration of the Inworld AI Runtime.
-- You can help the user learn {{target_language}} by having natural (verbalized) conversations with them.
-- The app generates flashcards for the user during the conversation. They are ANKI formatted and can be exported by the user.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const promptsDir = join(__dirname, '..', 'prompts');
 
-# Instructions
-- Greet the user and introduce yourself in {{target_language}}
-- If they don't want anything in particular, lead them in a conversation or lesson about {{example_topics}}, or any other topic which comes to mind
-{{language_instructions}}
-- Don't always ask the user questions, you can talk about yourself as well. Be natural!
-- As the user is a learner, you can offer them advise and feedback
+async function loadTemplate(name: string): Promise<string> {
+  const content = await readFile(join(promptsDir, `${name}.njk`), 'utf-8');
+  return content.trim();
+}
 
-# Communication Style
-- Use varied sentence structures
-- Generally, be terse, but expound if the user requests it
-- As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
-
-{% if messages and messages|length > 0 %}
-Previous conversation:
-{% for message in messages %}
-{{ message.role }}: {{ message.content }}
-{% endfor %}
-{% endif %}
-
-User just said: {{ current_input }}
-
-Please respond naturally and clearly in 1 sentence (or two if you have a lot to say).`.trim();
-
-// Note: introductionStatePromptTemplate removed - no longer collecting user info upfront
-
-export const flashcardPromptTemplate = `
-
-You are a system that generates flashcards for interesting new vocabulary for a {{target_language}} learning app.
-
-Based on the ongoing conversation between {{studentName}} and {{teacherName}}, generate one flashcard with the following things:
-
-- The word in {{target_language}}
-- The translation in English
-- An example sentence in {{target_language}}
-- A mnemonic to help the student remember the word
-
-## Conversation
-
-{% for message in messages %}
-{{message.role}}: {{message.content}}{% endfor %}
-
-## Already Created Flashcards
-
-{% for flashcard in flashcards %}
-- Word: {{flashcard.targetWord}}
-{% endfor %}
-
-## Guidelines
-
-- The word must NOT have been used in the conversation yet
-- The word must be related to the topics used in the conversation
-- The word must be related to the learner's level (if they are sophisticated, so can the word be. but if they are a beginner, the word should be simple or common)
-- The word should be useful to the learner so they can continue the conversation with new vocabulary
-
-Now, return JSON with the following format:
-
-{
-  "targetWord": "string",
-  "english": "string",
-  "example": "string",
-  "mnemonic": "string"
-}`.trim();
+export const conversationTemplate = await loadTemplate('conversation');
+export const flashcardPromptTemplate = await loadTemplate('flashcard');
+export const responseFeedbackPromptTemplate = await loadTemplate('response-feedback');
diff --git a/backend/prompts/conversation.njk b/backend/prompts/conversation.njk
new file mode 100644
index 0000000..776d25f
--- /dev/null
+++ b/backend/prompts/conversation.njk
@@ -0,0 +1,27 @@
+# Context
+- You are {{teacher_name}}, {{teacher_description}}.
+- You are embedded in a {{target_language}} learning app called 'Inworld Language Tutor', which is a demonstration of the Inworld AI Runtime.
+- You can help the user learn {{target_language}} by having natural (verbalized) conversations with them.
+- The app generates flashcards for the user during the conversation. They are ANKI formatted and can be exported by the user.
+
+# Instructions
+- Greet the user and introduce yourself in {{target_language}}
+- If they don't want anything in particular, lead them in a conversation or lesson about {{example_topics}}, or any other topic which comes to mind
+- Don't always ask the user questions, you can talk about yourself as well. Be natural!
+- As the user is a learner, you can offer them advise and feedback
+
+# Communication Style
+- Use varied sentence structures
+- Generally, be terse, but expound if the user requests it
+- As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
+
+{% if messages and messages|length > 0 %}
+Previous conversation:
+{% for message in messages %}
+{{ message.role }}: {{ message.content }}
+{% endfor %}
+{% endif %}
+
+User just said: {{ current_input }}
+
+Please respond naturally and clearly in 1 sentence (or two if you have a lot to say).
\ No newline at end of file
diff --git a/backend/prompts/flashcard.njk b/backend/prompts/flashcard.njk
new file mode 100644
index 0000000..2bbf54c
--- /dev/null
+++ b/backend/prompts/flashcard.njk
@@ -0,0 +1,35 @@
+You are a system that generates flashcards for interesting new vocabulary for a {{target_language}} learning app.
+
+Based on the ongoing conversation between {{studentName}} and {{teacherName}}, generate one flashcard with the following things:
+
+- The word in {{target_language}}
+- The translation in English
+- An example sentence in {{target_language}}
+- A mnemonic to help the student remember the word
+
+## Conversation
+
+{% for message in messages %}
+{{message.role}}: {{message.content}}{% endfor %}
+
+## Already Created Flashcards
+
+{% for flashcard in flashcards %}
+- Word: {{flashcard.targetWord}}
+{% endfor %}
+
+## Guidelines
+
+- The word must NOT have been used in the conversation yet
+- The word must be related to the topics used in the conversation
+- The word must be related to the learner's level (if they are sophisticated, so can the word be. but if they are a beginner, the word should be simple or common)
+- The word should be useful to the learner so they can continue the conversation with new vocabulary
+
+Now, return JSON with the following format:
+
+{
+  "targetWord": "string",
+  "english": "string",
+  "example": "string",
+  "mnemonic": "string"
+}
\ No newline at end of file
diff --git a/backend/prompts/response-feedback.njk b/backend/prompts/response-feedback.njk
new file mode 100644
index 0000000..3acbad5
--- /dev/null
+++ b/backend/prompts/response-feedback.njk
@@ -0,0 +1,17 @@
+You are a {{targetLanguage}} language tutor assistant. Your task is to analyze the student's most recent utterance and provide brief, helpful feedback.
+
+## Conversation so far:
+{% for message in messages %}
+{{ message.role }}: {{ message.content }}
+{% endfor %}
+
+## Student's last utterance:
+{{ currentTranscript }}
+
+## Instructions:
+- If the student made any grammar, vocabulary, or pronunciation errors in their {{targetLanguage}}, offer a gentle correction
+- If the student's response was good, offer a brief word of encouragement or a small tip to improve
+- Keep your feedback to exactly ONE sentence in English
+- Be encouraging and constructive
+
+Your feedback (one sentence in English):
\ No newline at end of file
diff --git a/backend/server.ts b/backend/server.ts
index d078365..05c5bd4 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -14,6 +14,7 @@ dotenv.config();
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -33,6 +34,8 @@ import { ConnectionsMap } from './types/index.js';
 // Import existing components (still compatible)
 import { FlashcardProcessor } from './helpers/flashcard-processor.js';
 import { FeedbackProcessor } from './helpers/feedback-processor.js';
+import { getFlashcardGraph } from './graphs/flashcard-graph.js';
+import { getResponseFeedbackGraph } from './graphs/response-feedback-graph.js';
 import { AnkiExporter } from './helpers/anki-exporter.js';
 import {
   getLanguageConfig,
@@ -83,6 +86,8 @@ try {
       appName: serverConfig.telemetry.appName,
       appVersion: serverConfig.telemetry.appVersion,
     });
+    logger.debug('telemetry_initialized');
+    logger.debug(`appName: ${serverConfig.telemetry.appName}`);
 
     telemetry.configureMetric({
       metricType: MetricType.CounterUInt,
@@ -116,6 +121,26 @@ async function initializeGraph(): Promise<void> {
   logger.info('conversation_graph_created');
 }
 
+async function exportGraphConfigs(): Promise<void> {
+  const configDir = path.join(__dirname, 'graphs/configs');
+
+  if (!existsSync(configDir)) {
+    await mkdir(configDir, { recursive: true });
+  }
+
+  const graphs = [
+    { id: 'flashcard-generation-graph', graph: getFlashcardGraph() },
+    { id: 'response-feedback-graph', graph: getResponseFeedbackGraph() },
+    ...(graphWrapper ? [{ id: 'lang-learning-conversation-graph', graph: graphWrapper.graph }] : []),
+  ];
+
+  for (const { id, graph } of graphs) {
+    const filePath = path.join(configDir, `${id}.json`);
+    await writeFile(filePath, graph.toJSON(), 'utf-8');
+    logger.info({ graphId: id, path: filePath }, 'graph_config_exported');
+  }
+}
+
 // ============================================================
 // WebSocket Connection Handler
 // ============================================================
@@ -432,6 +457,7 @@ app.use(express.static(finalStaticPath));
 async function startServer(): Promise<void> {
   try {
     await initializeGraph();
+    await exportGraphConfigs();
     server.listen(serverConfig.port, () => {
       logger.info({ port: serverConfig.port }, 'server_started');
       logger.info('using_inworld_runtime_0.9_with_assemblyai_stt');

From 0c1ef218d538ba64c899748cb13a87d7bca9ae31 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 11:15:51 -0800
Subject: [PATCH 18/49] update readme after breaking prompt templates into
 their own files

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 3654fa0..ee98307 100644
--- a/README.md
+++ b/README.md
@@ -94,9 +94,14 @@ language-learning-node/
 │   │   ├── audio-buffer.ts
 │   │   ├── audio-utils.ts
 │   │   ├── connection-manager.ts
+│   │   ├── feedback-processor.ts
 │   │   ├── flashcard-processor.ts
 │   │   ├── multimodal-stream-manager.ts
 │   │   └── prompt-templates.ts
+│   ├── prompts/              # Nunjucks prompt templates
+│   │   ├── conversation.njk
+│   │   ├── flashcard.njk
+│   │   └── response-feedback.njk
 │   ├── types/                # TypeScript type definitions
 │   ├── utils/                # Utility modules
 │   │   └── logger.ts         # Structured logging (pino)

From 5fb6928fc4b6ab5c3b26c5eb077cf6ddfa01fd46 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 11:20:12 -0800
Subject: [PATCH 19/49] updated flashcard prompt

---
 backend/prompts/flashcard.njk | 2 +-
 package-lock.json             | 8 ++++----
 package.json                  | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/backend/prompts/flashcard.njk b/backend/prompts/flashcard.njk
index 2bbf54c..b60ee9f 100644
--- a/backend/prompts/flashcard.njk
+++ b/backend/prompts/flashcard.njk
@@ -5,7 +5,7 @@ Based on the ongoing conversation between {{studentName}} and {{teacherName}}, g
 - The word in {{target_language}}
 - The translation in English
 - An example sentence in {{target_language}}
-- A mnemonic to help the student remember the word
+- A mnemonic to help the student remember the word (in English)
 
 ## Conversation
 
diff --git a/package-lock.json b/package-lock.json
index 482c25f..b42c3bc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "MIT",
       "dependencies": {
-        "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+        "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
         "anki-apkg-export": "^4.0.3",
         "dotenv": "^17.2.1",
         "express": "^4.19.2",
@@ -751,9 +751,9 @@
       }
     },
     "node_modules/@inworld/runtime": {
-      "version": "0.9.0-rc.13",
-      "resolved": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
-      "integrity": "sha512-6C/aND5PqOVzujwoS0rvUR963VxJ+MO0X+IZg9WpjrxBbuFag7fXay5yyamH0cKoTvmaTT2s8fca8pK0zQ0CYg==",
+      "version": "0.9.0-rc.14",
+      "resolved": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
+      "integrity": "sha512-Ukh19V5giiuCYGOjM4m8e4BmgO5YTVAup/J9UNJb5IgYY8Ht8lAhtG2Ni/6Y5e2w0WoKvr1I3zD6ro2tT5KyDQ==",
       "hasInstallScript": true,
       "license": "SEE LICENSE IN LICENSE.md and LICENSE-CPP-BINARIES.md",
       "dependencies": {
diff --git a/package.json b/package.json
index 0164f84..f1418f3 100644
--- a/package.json
+++ b/package.json
@@ -44,7 +44,7 @@
     "typescript-eslint": "^8.0.0"
   },
   "dependencies": {
-    "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.13.tgz",
+    "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
     "anki-apkg-export": "^4.0.3",
     "dotenv": "^17.2.1",
     "express": "^4.19.2",

From a0ee698d5323676421d0cccb50720e983da690d5 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 11:33:16 -0800
Subject: [PATCH 20/49] conversation prompt update

---
 backend/prompts/conversation.njk | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/backend/prompts/conversation.njk b/backend/prompts/conversation.njk
index 776d25f..4620553 100644
--- a/backend/prompts/conversation.njk
+++ b/backend/prompts/conversation.njk
@@ -14,6 +14,7 @@
 - Use varied sentence structures
 - Generally, be terse, but expound if the user requests it
 - As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
+- Ask open-ended questions to prompt the user to practice their Spanish
 
 {% if messages and messages|length > 0 %}
 Previous conversation:
@@ -24,4 +25,4 @@ Previous conversation:
 
 User just said: {{ current_input }}
 
-Please respond naturally and clearly in 1 sentence (or two if you have a lot to say).
\ No newline at end of file
+Please respond naturally and clearly in 1 short sentence (only be more verbose if the user specifically wants it).
\ No newline at end of file

From a5563ca5c3cf6c4d4325b3f380c87c13a3175611 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 13:10:44 -0800
Subject: [PATCH 21/49] updates to support production deployment

---
 .gitignore                                    |  4 +++
 backend/server.ts                             | 13 ++++++++++
 frontend/src/components/FlashcardsSection.tsx |  8 +++++-
 frontend/src/context/AppContext.tsx           | 24 +++++++++++++++---
 package-lock.json                             | 25 +++++++++++++++++++
 package.json                                  |  2 ++
 6 files changed, 71 insertions(+), 5 deletions(-)

diff --git a/.gitignore b/.gitignore
index bf5f0e7..2d6f407 100644
--- a/.gitignore
+++ b/.gitignore
@@ -144,3 +144,7 @@ backend/audio/
 CLAUDE.md
 templates/
 .claude
+
+# Deployment files
+deploy/
+.gcloudignore
diff --git a/backend/server.ts b/backend/server.ts
index 05c5bd4..ecf6c31 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -21,6 +21,7 @@ const __dirname = path.dirname(__filename);
 
 // Basic imports
 import express from 'express';
+import cors from 'cors';
 import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
 import { telemetry, stopInworldRuntime } from '@inworld/runtime';
@@ -52,6 +53,13 @@ const wss = new WebSocketServer({ server });
 // Add JSON parsing middleware
 app.use(express.json());
 
+// Add CORS middleware for Cloud Run deployment
+app.use(cors({
+  origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
+  methods: ['GET', 'POST', 'OPTIONS'],
+  credentials: true,
+}));
+
 // ============================================================
 // Global State
 // ============================================================
@@ -439,6 +447,11 @@ app.get('/api/languages', (_req, res) => {
   }
 });
 
+// Health check endpoint for Cloud Run
+app.get('/health', (_req, res) => {
+  res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() });
+});
+
 // ============================================================
 // Static Files
 // ============================================================
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
index bb6d2fc..6a0be2b 100644
--- a/frontend/src/components/FlashcardsSection.tsx
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -3,6 +3,12 @@ import { useApp } from '../context/AppContext';
 import { Flashcard } from './Flashcard';
 import type { Flashcard as FlashcardType } from '../types';
 
+// Helper for API URL for Cloud Run deployment
+const getApiUrl = (path: string): string => {
+  const backendUrl = import.meta.env.VITE_BACKEND_URL;
+  return backendUrl ? `${backendUrl}${path}` : path;
+};
+
 export function FlashcardsSection() {
   const { state, wsClient } = useApp();
   const { flashcards, currentLanguage } = state;
@@ -41,7 +47,7 @@ export function FlashcardsSection() {
       };
       const languageName = languageNames[currentLanguage] || 'Language';
 
-      const response = await fetch('/api/export-anki', {
+      const response = await fetch(getApiUrl('/api/export-anki'), {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 91b69e9..da708e1 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -21,6 +21,24 @@ import { WebSocketClient } from '../services/WebSocketClient';
 import { AudioHandler } from '../services/AudioHandler';
 import { AudioPlayer } from '../services/AudioPlayer';
 
+// Helper to determine WebSocket URL for Cloud Run deployment
+const getWebSocketUrl = (): string => {
+  const backendUrl = import.meta.env.VITE_BACKEND_URL;
+  if (backendUrl) {
+    // Convert https:// to wss:// or http:// to ws://
+    return backendUrl.replace(/^http/, 'ws');
+  }
+  // Local development: use same host with port 3000
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  return `${protocol}//${window.location.hostname}:3000`;
+};
+
+// Helper for API URL for Cloud Run deployment
+const getApiUrl = (path: string): string => {
+  const backendUrl = import.meta.env.VITE_BACKEND_URL;
+  return backendUrl ? `${backendUrl}${path}` : path;
+};
+
 // Action types
 type AppAction =
   | { type: 'SET_CONNECTION_STATUS'; payload: ConnectionStatus }
@@ -165,9 +183,7 @@ interface AppProviderProps {
 
 export function AppProvider({ children }: AppProviderProps) {
   const storageRef = useRef(new Storage());
-  const wsClientRef = useRef(
-    new WebSocketClient(`ws://${window.location.hostname}:3000`)
-  );
+  const wsClientRef = useRef(new WebSocketClient(getWebSocketUrl()));
   const audioHandlerRef = useRef(new AudioHandler());
   const audioPlayerRef = useRef(new AudioPlayer());
 
@@ -211,7 +227,7 @@ export function AppProvider({ children }: AppProviderProps) {
   useEffect(() => {
     const fetchLanguages = async () => {
       try {
-        const response = await fetch('/api/languages');
+        const response = await fetch(getApiUrl('/api/languages'));
         if (response.ok) {
           const data = await response.json();
           dispatch({
diff --git a/package-lock.json b/package-lock.json
index b42c3bc..ce9bda8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,6 +11,7 @@
       "dependencies": {
         "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
         "anki-apkg-export": "^4.0.3",
+        "cors": "^2.8.5",
         "dotenv": "^17.2.1",
         "express": "^4.19.2",
         "pino": "^10.1.0",
@@ -20,6 +21,7 @@
       "devDependencies": {
         "@eslint/js": "^9.0.0",
         "@tsconfig/node-lts": "^22.0.2",
+        "@types/cors": "^2.8.19",
         "@types/express": "^4.17.21",
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.12",
@@ -927,6 +929,16 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -2009,6 +2021,19 @@
       "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
       "license": "MIT"
     },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
diff --git a/package.json b/package.json
index f1418f3..3a01911 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,7 @@
   "devDependencies": {
     "@eslint/js": "^9.0.0",
     "@tsconfig/node-lts": "^22.0.2",
+    "@types/cors": "^2.8.19",
     "@types/express": "^4.17.21",
     "@types/node": "^20.0.0",
     "@types/ws": "^8.5.12",
@@ -46,6 +47,7 @@
   "dependencies": {
     "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
     "anki-apkg-export": "^4.0.3",
+    "cors": "^2.8.5",
     "dotenv": "^17.2.1",
     "express": "^4.19.2",
     "pino": "^10.1.0",

From a85075a46e38a4aab1be1454d9db076bbc2d589d Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 31 Dec 2025 13:15:12 -0800
Subject: [PATCH 22/49] linting fixes

---
 README.md                                     | 20 ++---
 backend/config/languages.ts                   |  5 +-
 backend/config/server.ts                      | 17 ++--
 backend/graphs/conversation-graph.ts          |  5 +-
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   | 79 ++++++++++++++-----
 .../nodes/dialog-prompt-builder-node.ts       |  5 +-
 .../graphs/nodes/interaction-queue-node.ts    | 29 +++++--
 backend/graphs/nodes/state-update-node.ts     | 15 +++-
 backend/graphs/nodes/text-input-node.ts       |  5 +-
 .../graphs/nodes/transcript-extractor-node.ts |  6 +-
 backend/helpers/connection-manager.ts         | 21 +++--
 backend/helpers/feedback-processor.ts         | 10 +--
 backend/helpers/flashcard-processor.ts        |  5 +-
 backend/helpers/prompt-templates.ts           |  3 +-
 backend/server.ts                             | 60 ++++++++++----
 backend/types/index.ts                        |  1 -
 backend/utils/logger.ts                       |  5 +-
 17 files changed, 208 insertions(+), 83 deletions(-)

diff --git a/README.md b/README.md
index ee98307..af5c782 100644
--- a/README.md
+++ b/README.md
@@ -45,19 +45,19 @@ Get your Inworld Base64 API key from the [Inworld Portal](https://platform.inwor
 
 ### Required
 
-| Variable | Description |
-|----------|-------------|
-| `INWORLD_API_KEY` | Your Inworld AI API key (Base64 encoded) from the [Inworld Portal](https://platform.inworld.ai/) |
-| `ASSEMBLY_AI_API_KEY` | Your Assembly AI API key for speech-to-text |
+| Variable              | Description                                                                                      |
+| --------------------- | ------------------------------------------------------------------------------------------------ |
+| `INWORLD_API_KEY`     | Your Inworld AI API key (Base64 encoded) from the [Inworld Portal](https://platform.inworld.ai/) |
+| `ASSEMBLY_AI_API_KEY` | Your Assembly AI API key for speech-to-text                                                      |
 
 ### Optional
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `PORT` | `3000` | Server port number |
-| `LOG_LEVEL` | `info` | Logging level. Options: `trace`, `debug`, `info`, `warn`, `error`, `fatal` |
-| `NODE_ENV` | `development` | Environment mode. Set to `production` for JSON logs (no pretty-printing) |
-| `ASSEMBLY_AI_EAGERNESS` | `medium` | Turn detection sensitivity for speech-to-text. Options: `low` (conservative, allows thinking pauses), `medium` (balanced), `high` (aggressive, quick responses) |
+| Variable                | Default       | Description                                                                                                                                                     |
+| ----------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `PORT`                  | `3000`        | Server port number                                                                                                                                              |
+| `LOG_LEVEL`             | `info`        | Logging level. Options: `trace`, `debug`, `info`, `warn`, `error`, `fatal`                                                                                      |
+| `NODE_ENV`              | `development` | Environment mode. Set to `production` for JSON logs (no pretty-printing)                                                                                        |
+| `ASSEMBLY_AI_EAGERNESS` | `medium`      | Turn detection sensitivity for speech-to-text. Options: `low` (conservative, allows thinking pauses), `medium` (balanced), `high` (aggressive, quick responses) |
 
 ### Step 4: Run the Application
 
diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index a0b2f68..01a1949 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -245,7 +245,10 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
 export function getLanguageConfig(code: string): LanguageConfig {
   const config = SUPPORTED_LANGUAGES[code];
   if (!config) {
-    logger.warn({ requestedCode: code, fallback: 'es' }, 'language_not_found_using_fallback');
+    logger.warn(
+      { requestedCode: code, fallback: 'es' },
+      'language_not_found_using_fallback'
+    );
     return SUPPORTED_LANGUAGES['es'];
   }
   return config;
diff --git a/backend/config/server.ts b/backend/config/server.ts
index bfda92c..6ab5513 100644
--- a/backend/config/server.ts
+++ b/backend/config/server.ts
@@ -18,7 +18,10 @@ export type AssemblyAIEagerness = 'low' | 'medium' | 'high';
  * AssemblyAI turn detection presets based on their documentation
  * @see https://www.assemblyai.com/docs/speech-to-text/universal-streaming/turn-detection
  */
-const assemblyAIPresets: Record<AssemblyAIEagerness, AssemblyAITurnDetectionSettings> = {
+const assemblyAIPresets: Record<
+  AssemblyAIEagerness,
+  AssemblyAITurnDetectionSettings
+> = {
   /**
    * Aggressive - Quick responses for rapid back-and-forth
    * Use cases: Agent Assist, IVR replacements, Retail/E-commerce, Telecom
@@ -27,7 +30,8 @@ const assemblyAIPresets: Record<AssemblyAIEagerness, AssemblyAITurnDetectionSett
     endOfTurnConfidenceThreshold: 0.4,
     minEndOfTurnSilenceWhenConfident: 160,
     maxTurnSilence: 400,
-    description: 'Aggressive - Quick responses for rapid back-and-forth (IVR, order confirmations)',
+    description:
+      'Aggressive - Quick responses for rapid back-and-forth (IVR, order confirmations)',
   },
 
   /**
@@ -38,7 +42,8 @@ const assemblyAIPresets: Record<AssemblyAIEagerness, AssemblyAITurnDetectionSett
     endOfTurnConfidenceThreshold: 0.4,
     minEndOfTurnSilenceWhenConfident: 400,
     maxTurnSilence: 1280,
-    description: 'Balanced - Natural middle ground for most conversational turns',
+    description:
+      'Balanced - Natural middle ground for most conversational turns',
   },
 
   /**
@@ -49,7 +54,8 @@ const assemblyAIPresets: Record<AssemblyAIEagerness, AssemblyAITurnDetectionSett
     endOfTurnConfidenceThreshold: 0.7,
     minEndOfTurnSilenceWhenConfident: 800,
     maxTurnSilence: 3600,
-    description: 'Conservative - Patient, allows thinking pauses (Language Learning, Healthcare)',
+    description:
+      'Conservative - Patient, allows thinking pauses (Language Learning, Healthcare)',
   },
 };
 
@@ -74,7 +80,8 @@ export const serverConfig = {
    */
   assemblyAI: {
     /** Turn detection eagerness level */
-    eagerness: (process.env.ASSEMBLY_AI_EAGERNESS || 'medium') as AssemblyAIEagerness,
+    eagerness: (process.env.ASSEMBLY_AI_EAGERNESS ||
+      'medium') as AssemblyAIEagerness,
     /** Format turns in output (typically false for real-time processing) */
     formatTurns: false,
   },
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 85e1b82..82ca2d3 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -36,10 +36,7 @@ import {
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
 import { llmConfig } from '../config/llm.js';
-import {
-  serverConfig,
-  getAssemblyAISettings,
-} from '../config/server.js';
+import { serverConfig, getAssemblyAISettings } from '../config/server.js';
 import { graphLogger as logger } from '../utils/logger.js';
 
 export interface ConversationGraphConfig {
diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index 5f15b91..8762622 100644
--- a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -66,7 +66,10 @@ class AssemblyAISession {
       isExpired
     ) {
       if (isExpired) {
-        logger.info({ sessionId: this.sessionId }, 'session_expired_reconnecting');
+        logger.info(
+          { sessionId: this.sessionId },
+          'session_expired_reconnecting'
+        );
       }
       this.closeWebSocket();
       this.initializeWebSocket();
@@ -101,7 +104,10 @@ class AssemblyAISession {
           if (message.type === 'Begin') {
             this.assemblySessionId = message.id || message.session_id || '';
             this.sessionExpiresAt = message.expires_at || 0;
-            logger.debug({ assemblySessionId: this.assemblySessionId }, 'session_began');
+            logger.debug(
+              { assemblySessionId: this.assemblySessionId },
+              'session_began'
+            );
           }
         } catch {
           // Ignore parsing errors
@@ -152,7 +158,10 @@ class AssemblyAISession {
 
   private closeDueToInactivity(): void {
     const inactiveFor = Date.now() - this.lastActivityTime;
-    logger.info({ sessionId: this.sessionId, inactiveMs: inactiveFor }, 'closing_due_to_inactivity');
+    logger.info(
+      { sessionId: this.sessionId, inactiveMs: inactiveFor },
+      'closing_due_to_inactivity'
+    );
     this.shouldStopProcessing = true;
     this.close();
     this.onCleanup(this.sessionId);
@@ -243,11 +252,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       config.minEndOfTurnSilenceWhenConfident ?? 800;
     this.maxTurnSilence = config.maxTurnSilence ?? 3600;
 
-    logger.info({
-      threshold: this.endOfTurnConfidenceThreshold,
-      minSilenceMs: this.minEndOfTurnSilenceWhenConfident,
-      maxSilenceMs: this.maxTurnSilence,
-    }, 'stt_node_configured');
+    logger.info(
+      {
+        threshold: this.endOfTurnConfidenceThreshold,
+        minSilenceMs: this.minEndOfTurnSilenceWhenConfident,
+        maxSilenceMs: this.maxTurnSilence,
+      },
+      'stt_node_configured'
+    );
   }
 
   /**
@@ -268,11 +280,14 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
     });
 
     const url = `${this.wsEndpointBaseUrl}?${params.toString()}`;
-    logger.debug({
-      model: 'universal-streaming-multilingual',
-      threshold: this.endOfTurnConfidenceThreshold,
-      maxSilenceMs: this.maxTurnSilence,
-    }, 'connecting_to_assemblyai');
+    logger.debug(
+      {
+        model: 'universal-streaming-multilingual',
+        threshold: this.endOfTurnConfidenceThreshold,
+        maxSilenceMs: this.maxTurnSilence,
+      },
+      'connecting_to_assemblyai'
+    );
 
     return url;
   }
@@ -414,11 +429,20 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             // Stitch the pending transcript with the new one
             finalTranscript =
               `${connection.pendingTranscript} ${transcript}`.trim();
-            logger.debug({ iteration, transcriptSnippet: finalTranscript.substring(0, 80) }, 'stitched_transcript');
+            logger.debug(
+              {
+                iteration,
+                transcriptSnippet: finalTranscript.substring(0, 80),
+              },
+              'stitched_transcript'
+            );
             // Clear the pending transcript
             connection.pendingTranscript = undefined;
           } else {
-            logger.debug({ iteration, transcriptSnippet: transcript.substring(0, 50) }, 'turn_detected');
+            logger.debug(
+              { iteration, transcriptSnippet: transcript.substring(0, 50) },
+              'turn_detected'
+            );
           }
 
           // Clear interrupt flag for new processing
@@ -455,14 +479,20 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
             if (session?.shouldStopProcessing) break;
 
             if (maxDurationReached && !transcriptText) {
-              logger.warn({ maxDurationMs: this.MAX_TRANSCRIPTION_DURATION_MS }, 'max_transcription_duration_reached');
+              logger.warn(
+                { maxDurationMs: this.MAX_TRANSCRIPTION_DURATION_MS },
+                'max_transcription_duration_reached'
+              );
               break;
             }
 
             const result = await multimodalStream.next();
 
             if (result.done) {
-              logger.debug({ iteration, audioChunkCount }, 'multimodal_stream_exhausted');
+              logger.debug(
+                { iteration, audioChunkCount },
+                'multimodal_stream_exhausted'
+              );
               isStreamExhausted = true;
               break;
             }
@@ -473,7 +503,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
             // Handle text input
             if (content.text !== undefined && content.text !== null) {
-              logger.debug({ iteration, textSnippet: content.text.substring(0, 50) }, 'text_input_detected');
+              logger.debug(
+                { iteration, textSnippet: content.text.substring(0, 50) },
+                'text_input_detected'
+              );
               isTextInput = true;
               textContent = content.text;
               transcriptText = content.text;
@@ -517,7 +550,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
         !turnCompleted &&
         !maxDurationReached
       ) {
-        logger.debug({ waitMs: this.TURN_COMPLETION_TIMEOUT_MS }, 'audio_ended_before_turn_waiting');
+        logger.debug(
+          { waitMs: this.TURN_COMPLETION_TIMEOUT_MS },
+          'audio_ended_before_turn_waiting'
+        );
 
         // Send silence to keep connection alive - AssemblyAI needs continuous audio
         const silenceIntervalMs = 100;
@@ -553,7 +589,10 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
 
       await audioProcessingPromise.catch(() => {});
 
-      logger.debug({ iteration, transcriptSnippet: transcriptText?.substring(0, 50) }, 'transcription_complete');
+      logger.debug(
+        { iteration, transcriptSnippet: transcriptText?.substring(0, 50) },
+        'transcription_complete'
+      );
 
       if (turnDetected) {
         connection.state.interactionId = '';
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index fde1958..d1d9be4 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -33,7 +33,10 @@ export class DialogPromptBuilderNode extends CustomNode {
     state: State
   ): Promise<GraphTypes.LLMChatRequest> {
     logger.debug(
-      { languageCode: state.languageCode || 'es', messageCount: state.messages?.length || 0 },
+      {
+        languageCode: state.languageCode || 'es',
+        messageCount: state.messages?.length || 0,
+      },
       'building_prompt'
     );
 
diff --git a/backend/graphs/nodes/interaction-queue-node.ts b/backend/graphs/nodes/interaction-queue-node.ts
index d8cf668..7cdfebf 100644
--- a/backend/graphs/nodes/interaction-queue-node.ts
+++ b/backend/graphs/nodes/interaction-queue-node.ts
@@ -38,7 +38,10 @@ export class InteractionQueueNode extends CustomNode {
     state: State
   ): TextInput {
     const sessionId = interactionInfo.sessionId;
-    logger.debug({ interactionId: interactionInfo.interactionId }, 'processing_interaction');
+    logger.debug(
+      { interactionId: interactionInfo.interactionId },
+      'processing_interaction'
+    );
 
     // Get current voiceId from connection state
     const connection = this.connections[sessionId];
@@ -55,7 +58,10 @@ export class InteractionQueueNode extends CustomNode {
         QUEUED_PREFIX + interactionInfo.interactionId,
         interactionInfo.text
       );
-      logger.debug({ interactionId: interactionInfo.interactionId }, 'interaction_queued');
+      logger.debug(
+        { interactionId: interactionInfo.interactionId },
+        'interaction_queued'
+      );
     }
 
     // Get all keys and categorize them
@@ -86,7 +92,14 @@ export class InteractionQueueNode extends CustomNode {
       return getIteration(a) - getIteration(b);
     });
 
-    logger.debug({ queued: queuedIds.length, completed: completedCount, running: runningCount }, 'queue_state');
+    logger.debug(
+      {
+        queued: queuedIds.length,
+        completed: completedCount,
+        running: runningCount,
+      },
+      'queue_state'
+    );
 
     // Decide if we should start processing the next interaction
     if (queuedIds.length === 0) {
@@ -137,7 +150,10 @@ export class InteractionQueueNode extends CustomNode {
         };
       }
 
-      logger.debug({ textSnippet: queuedText.substring(0, 50) }, 'starting_llm_processing');
+      logger.debug(
+        { textSnippet: queuedText.substring(0, 50) },
+        'starting_llm_processing'
+      );
 
       return {
         text: queuedText,
@@ -147,7 +163,10 @@ export class InteractionQueueNode extends CustomNode {
       };
     } else {
       // An interaction is currently running, wait
-      logger.debug({ waitingFor: queuedIds[completedCount] }, 'waiting_for_interaction');
+      logger.debug(
+        { waitingFor: queuedIds[completedCount] },
+        'waiting_for_interaction'
+      );
       return {
         text: '',
         sessionId: sessionId,
diff --git a/backend/graphs/nodes/state-update-node.ts b/backend/graphs/nodes/state-update-node.ts
index 4fb2917..cfae532 100644
--- a/backend/graphs/nodes/state-update-node.ts
+++ b/backend/graphs/nodes/state-update-node.ts
@@ -30,7 +30,10 @@ export class StateUpdateNode extends CustomNode {
 
   process(context: ProcessContext, llmOutput: string): State {
     const sessionId = context.getDatastore().get('sessionId') as string;
-    logger.debug({ outputLength: llmOutput?.length || 0 }, 'state_update_processing');
+    logger.debug(
+      { outputLength: llmOutput?.length || 0 },
+      'state_update_processing'
+    );
 
     const connection = this.connections[sessionId];
     if (connection?.unloaded) {
@@ -42,7 +45,10 @@ export class StateUpdateNode extends CustomNode {
 
     // Only add assistant message if there's actual content
     if (llmOutput && llmOutput.trim().length > 0) {
-      logger.debug({ messageSnippet: llmOutput.substring(0, 50) }, 'adding_assistant_message');
+      logger.debug(
+        { messageSnippet: llmOutput.substring(0, 50) },
+        'adding_assistant_message'
+      );
       connection.state.messages.push({
         role: 'assistant',
         content: llmOutput,
@@ -56,7 +62,10 @@ export class StateUpdateNode extends CustomNode {
     // Mark interaction as completed
     const dataStore = context.getDatastore();
     dataStore.add('c' + connection.state.interactionId, '');
-    logger.debug({ interactionId: connection.state.interactionId }, 'interaction_completed');
+    logger.debug(
+      { interactionId: connection.state.interactionId },
+      'interaction_completed'
+    );
 
     return connection.state;
   }
diff --git a/backend/graphs/nodes/text-input-node.ts b/backend/graphs/nodes/text-input-node.ts
index d933afe..1508884 100644
--- a/backend/graphs/nodes/text-input-node.ts
+++ b/backend/graphs/nodes/text-input-node.ts
@@ -28,7 +28,10 @@ export class TextInputNode extends CustomNode {
   }
 
   process(_context: ProcessContext, input: TextInput): State {
-    logger.debug({ textSnippet: input.text?.substring(0, 50) }, 'text_input_processing');
+    logger.debug(
+      { textSnippet: input.text?.substring(0, 50) },
+      'text_input_processing'
+    );
 
     const { text, interactionId, sessionId } = input;
 
diff --git a/backend/graphs/nodes/transcript-extractor-node.ts b/backend/graphs/nodes/transcript-extractor-node.ts
index ed38048..75d6132 100644
--- a/backend/graphs/nodes/transcript-extractor-node.ts
+++ b/backend/graphs/nodes/transcript-extractor-node.ts
@@ -35,7 +35,11 @@ export class TranscriptExtractorNode extends CustomNode {
     const interactionId = String(metadata.interactionId || iteration);
 
     logger.debug(
-      { iteration, transcriptSnippet: transcript?.substring(0, 50), interactionComplete },
+      {
+        iteration,
+        transcriptSnippet: transcript?.substring(0, 50),
+        interactionComplete,
+      },
       'transcript_extracted'
     );
 
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index 32e1ef9..a76a242 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -87,7 +87,10 @@ export class ConnectionManager {
         this.handlePartialTranscript(text, interactionId),
     };
 
-    this.logger.info({ language: this.languageConfig.name }, 'connection_manager_created');
+    this.logger.info(
+      { language: this.languageConfig.name },
+      'connection_manager_created'
+    );
   }
 
   /**
@@ -298,8 +301,12 @@ export class ConnectionManager {
               if (isFirstChunk) {
                 this.logger.debug(
                   {
-                    sampleRate: chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
-                    bytes: Array.isArray(chunk.audio.data) ? chunk.audio.data.length : 'N/A',
+                    sampleRate:
+                      chunk.audio.sampleRate ||
+                      serverConfig.audio.ttsSampleRate,
+                    bytes: Array.isArray(chunk.audio.data)
+                      ? chunk.audio.data.length
+                      : 'N/A',
                   },
                   'tts_audio_chunk'
                 );
@@ -313,7 +320,8 @@ export class ConnectionManager {
                   type: 'audio_stream',
                   audio: audioResult.base64,
                   audioFormat: audioResult.format,
-                  sampleRate: chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
+                  sampleRate:
+                    chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
                   text: chunk.text || '',
                   isFirstChunk: isFirstChunk,
                   timestamp: Date.now(),
@@ -671,7 +679,10 @@ export class ConnectionManager {
       connection.state.voiceId = this.languageConfig.ttsConfig.speakerId;
     }
 
-    this.logger.info({ language: this.languageConfig.name }, 'language_changed');
+    this.logger.info(
+      { language: this.languageConfig.name },
+      'language_changed'
+    );
   }
 
   /**
diff --git a/backend/helpers/feedback-processor.ts b/backend/helpers/feedback-processor.ts
index e67a612..c0458c9 100644
--- a/backend/helpers/feedback-processor.ts
+++ b/backend/helpers/feedback-processor.ts
@@ -47,7 +47,10 @@ export class FeedbackProcessor {
 
     // Remove the last assistant message so conversation ends with user's utterance
     let conversationMessages = messages;
-    if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+    if (
+      messages.length > 0 &&
+      messages[messages.length - 1].role === 'assistant'
+    ) {
       conversationMessages = messages.slice(0, -1);
     }
 
@@ -66,10 +69,7 @@ export class FeedbackProcessor {
         };
         executionResult = await executor.start(input, executionContext);
       } catch (err) {
-        logger.warn(
-          { err },
-          'executor_start_with_context_failed_falling_back'
-        );
+        logger.warn({ err }, 'executor_start_with_context_failed_falling_back');
         executionResult = await executor.start(input);
       }
 
diff --git a/backend/helpers/flashcard-processor.ts b/backend/helpers/flashcard-processor.ts
index aa15b9e..b08fdec 100644
--- a/backend/helpers/flashcard-processor.ts
+++ b/backend/helpers/flashcard-processor.ts
@@ -109,10 +109,7 @@ export class FlashcardProcessor {
         };
         executionResult = await executor.start(input, executionContext);
       } catch (err) {
-        logger.warn(
-          { err },
-          'executor_start_with_context_failed_falling_back'
-        );
+        logger.warn({ err }, 'executor_start_with_context_failed_falling_back');
         executionResult = await executor.start(input);
       }
       let finalData: GraphTypes.Content | null = null;
diff --git a/backend/helpers/prompt-templates.ts b/backend/helpers/prompt-templates.ts
index 13b56af..9001b17 100644
--- a/backend/helpers/prompt-templates.ts
+++ b/backend/helpers/prompt-templates.ts
@@ -25,4 +25,5 @@ async function loadTemplate(name: string): Promise<string> {
 
 export const conversationTemplate = await loadTemplate('conversation');
 export const flashcardPromptTemplate = await loadTemplate('flashcard');
-export const responseFeedbackPromptTemplate = await loadTemplate('response-feedback');
+export const responseFeedbackPromptTemplate =
+  await loadTemplate('response-feedback');
diff --git a/backend/server.ts b/backend/server.ts
index ecf6c31..604b69b 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -54,11 +54,13 @@ const wss = new WebSocketServer({ server });
 app.use(express.json());
 
 // Add CORS middleware for Cloud Run deployment
-app.use(cors({
-  origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
-  methods: ['GET', 'POST', 'OPTIONS'],
-  credentials: true,
-}));
+app.use(
+  cors({
+    origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
+    methods: ['GET', 'POST', 'OPTIONS'],
+    credentials: true,
+  })
+);
 
 // ============================================================
 // Global State
@@ -139,7 +141,9 @@ async function exportGraphConfigs(): Promise<void> {
   const graphs = [
     { id: 'flashcard-generation-graph', graph: getFlashcardGraph() },
     { id: 'response-feedback-graph', graph: getResponseFeedbackGraph() },
-    ...(graphWrapper ? [{ id: 'lang-learning-conversation-graph', graph: graphWrapper.graph }] : []),
+    ...(graphWrapper
+      ? [{ id: 'lang-learning-conversation-graph', graph: graphWrapper.graph }]
+      : []),
   ];
 
   for (const { id, graph } of graphs) {
@@ -190,7 +194,10 @@ wss.on('connection', async (ws) => {
   // Set up flashcard generation callback
   connectionManager.setFlashcardCallback(async (messages) => {
     if (isShuttingDown) {
-      logger.debug({ connectionId }, 'skipping_flashcard_generation_shutting_down');
+      logger.debug(
+        { connectionId },
+        'skipping_flashcard_generation_shutting_down'
+      );
       return;
     }
 
@@ -221,7 +228,10 @@ wss.on('connection', async (ws) => {
       }
     } catch (error) {
       if (!isShuttingDown) {
-        logger.error({ err: error, connectionId }, 'flashcard_generation_error');
+        logger.error(
+          { err: error, connectionId },
+          'flashcard_generation_error'
+        );
       }
     }
   });
@@ -229,7 +239,10 @@ wss.on('connection', async (ws) => {
   // Set up feedback generation callback
   connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
     if (isShuttingDown) {
-      logger.debug({ connectionId }, 'skipping_feedback_generation_shutting_down');
+      logger.debug(
+        { connectionId },
+        'skipping_feedback_generation_shutting_down'
+      );
       return;
     }
 
@@ -331,7 +344,10 @@ wss.on('connection', async (ws) => {
             })
           );
 
-          logger.info({ connectionId, language: languageConfig.name }, 'language_changed');
+          logger.info(
+            { connectionId, language: languageConfig.name },
+            'language_changed'
+          );
         }
       } else if (message.type === 'user_context') {
         const timezone = message.timezone || message.data?.timezone;
@@ -358,13 +374,19 @@ wss.on('connection', async (ws) => {
             languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
           });
         } catch (error) {
-          logger.error({ err: error, connectionId }, 'flashcard_click_record_error');
+          logger.error(
+            { err: error, connectionId },
+            'flashcard_click_record_error'
+          );
         }
       } else if (message.type === 'text_message' && message.text) {
         // Handle text input (bypasses audio/STT)
         connectionManager.sendTextMessage(message.text);
       } else {
-        logger.debug({ connectionId, messageType: message.type }, 'received_message');
+        logger.debug(
+          { connectionId, messageType: message.type },
+          'received_message'
+        );
       }
     } catch (error) {
       logger.error({ err: error, connectionId }, 'message_processing_error');
@@ -384,7 +406,10 @@ wss.on('connection', async (ws) => {
       try {
         await manager.destroy();
       } catch (error) {
-        logger.error({ err: error, connectionId }, 'connection_manager_destroy_error');
+        logger.error(
+          { err: error, connectionId },
+          'connection_manager_destroy_error'
+        );
       }
       connectionManagers.delete(connectionId);
     }
@@ -449,7 +474,9 @@ app.get('/api/languages', (_req, res) => {
 
 // Health check endpoint for Cloud Run
 app.get('/health', (_req, res) => {
-  res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() });
+  res
+    .status(200)
+    .json({ status: 'healthy', timestamp: new Date().toISOString() });
 });
 
 // ============================================================
@@ -495,7 +522,10 @@ async function gracefulShutdown(): Promise<void> {
 
   try {
     // Close all WebSocket connections
-    logger.info({ connectionCount: wss.clients.size }, 'closing_websocket_connections');
+    logger.info(
+      { connectionCount: wss.clients.size },
+      'closing_websocket_connections'
+    );
     wss.clients.forEach((ws) => {
       if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
         ws.close();
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 781c43b..6ea7836 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -73,4 +73,3 @@ export interface InteractionInfo {
   text: string;
   interactionComplete: boolean;
 }
-
diff --git a/backend/utils/logger.ts b/backend/utils/logger.ts
index 782e413..3403cb8 100644
--- a/backend/utils/logger.ts
+++ b/backend/utils/logger.ts
@@ -43,7 +43,10 @@ export function createLogger(module: string): pino.Logger {
  * @param module - Module name
  * @param sessionId - Session/connection identifier
  */
-export function createSessionLogger(module: string, sessionId: string): pino.Logger {
+export function createSessionLogger(
+  module: string,
+  sessionId: string
+): pino.Logger {
   return logger.child({ module, sessionId });
 }
 

From 23aad2b7e8ce2c428b470a096a71807edfc74a97 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Fri, 2 Jan 2026 18:33:44 -0800
Subject: [PATCH 23/49] Feat: added DB persistence with supabase

---
 README.md                                     |  156 +-
 backend/__tests__/config/languages.test.ts    |  156 +
 .../__tests__/helpers/anki-exporter.test.ts   |   94 +
 backend/__tests__/helpers/audio-utils.test.ts |  164 +
 backend/config/languages.ts                   |    2 +-
 .../lang-learning-conversation-graph.json     |    4 +-
 backend/graphs/conversation-graph.ts          |   26 +
 backend/prompts/conversation.njk              |    2 +-
 backend/prompts/flashcard.njk                 |    3 +-
 backend/prompts/response-feedback.njk         |    1 +
 backend/server.ts                             |  522 +---
 backend/services/api-routes.ts                |   69 +
 backend/services/graph-service.ts             |   74 +
 backend/services/shutdown.ts                  |   63 +
 backend/services/state.ts                     |   33 +
 backend/services/telemetry.ts                 |   36 +
 backend/services/websocket-handler.ts         |  365 +++
 backend/vitest.config.ts                      |   14 +
 frontend/package-lock.json                    | 2307 +++++++++++++-
 frontend/package.json                         |    9 +-
 frontend/src/App.tsx                          |   28 +-
 .../src/__tests__/services/Storage.test.ts    |  346 +++
 frontend/src/__tests__/setup.ts               |   36 +
 frontend/src/components/ChatSection.tsx       |   86 +-
 frontend/src/components/Header.tsx            |  197 +-
 frontend/src/components/Sidebar.tsx           |  259 ++
 frontend/src/context/AppContext.tsx           |  490 ++-
 frontend/src/context/AuthContext.tsx          |  118 +
 frontend/src/main.tsx                         |    5 +-
 frontend/src/services/HybridStorage.ts        |  236 ++
 frontend/src/services/Storage.ts              |  315 +-
 frontend/src/services/SupabaseStorage.ts      |  272 ++
 frontend/src/styles/main.css                  |  778 ++++-
 frontend/src/types/index.ts                   |   20 +
 frontend/vitest.config.ts                     |   12 +
 package-lock.json                             | 2726 ++++++++++++++++-
 package.json                                  |    9 +-
 supabase/config.toml                          |   10 +
 supabase/migrations/00001_schema.sql          |   62 +
 39 files changed, 9173 insertions(+), 932 deletions(-)
 create mode 100644 backend/__tests__/config/languages.test.ts
 create mode 100644 backend/__tests__/helpers/anki-exporter.test.ts
 create mode 100644 backend/__tests__/helpers/audio-utils.test.ts
 create mode 100644 backend/services/api-routes.ts
 create mode 100644 backend/services/graph-service.ts
 create mode 100644 backend/services/shutdown.ts
 create mode 100644 backend/services/state.ts
 create mode 100644 backend/services/telemetry.ts
 create mode 100644 backend/services/websocket-handler.ts
 create mode 100644 backend/vitest.config.ts
 create mode 100644 frontend/src/__tests__/services/Storage.test.ts
 create mode 100644 frontend/src/__tests__/setup.ts
 create mode 100644 frontend/src/components/Sidebar.tsx
 create mode 100644 frontend/src/context/AuthContext.tsx
 create mode 100644 frontend/src/services/HybridStorage.ts
 create mode 100644 frontend/src/services/SupabaseStorage.ts
 create mode 100644 frontend/vitest.config.ts
 create mode 100644 supabase/config.toml
 create mode 100644 supabase/migrations/00001_schema.sql

diff --git a/README.md b/README.md
index af5c782..4e56458 100644
--- a/README.md
+++ b/README.md
@@ -5,15 +5,16 @@
 [![Documentation](https://img.shields.io/badge/Documentation-Read_Docs-blue)](https://docs.inworld.ai/docs/node/overview)
 [![Model Providers](https://img.shields.io/badge/Model_Providers-See_Models-purple)](https://docs.inworld.ai/docs/models#llm)
 
-A Node.js app where you can learn languages through conversation and flashcard studying, powered by Inworld AI Runtime. This is a demonstration of the Inworld Runtime Node.js SDK.
+A conversational language learning app powered by Inworld AI Runtime. Practice speaking with an AI tutor, get real-time feedback on your responses, and build vocabulary with auto-generated flashcards.
 
 ![App](screenshot.jpg)
 
 ## Prerequisites
 
 - Node.js (v20 or higher)
+- npm
 - An Inworld AI account and API key
-- An Assembly AI account and API key
+- An AssemblyAI account and API key (for speech-to-text)
 
 ## Get Started
 
@@ -35,100 +36,123 @@ npm install
 Create a `.env` file in the root directory:
 
 ```bash
-INWORLD_API_KEY=your_api_key_here
-ASSEMBLY_AI_API_KEY=your_api_key_here
+INWORLD_API_KEY=your_inworld_base64_key
+ASSEMBLY_AI_API_KEY=your_assemblyai_key
 ```
 
-Get your Inworld Base64 API key from the [Inworld Portal](https://platform.inworld.ai/).
+| Service | Get Key From | Purpose |
+|---------|-------------|---------|
+| **Inworld** | [platform.inworld.ai](https://platform.inworld.ai/) | AI conversations (Base64 API key) |
+| **AssemblyAI** | [assemblyai.com](https://www.assemblyai.com/) | Speech-to-text |
 
-## Environment Variables
+### Step 4: Run the Application
 
-### Required
+**For development** (with auto-reload on file changes):
 
-| Variable              | Description                                                                                      |
-| --------------------- | ------------------------------------------------------------------------------------------------ |
-| `INWORLD_API_KEY`     | Your Inworld AI API key (Base64 encoded) from the [Inworld Portal](https://platform.inworld.ai/) |
-| `ASSEMBLY_AI_API_KEY` | Your Assembly AI API key for speech-to-text                                                      |
+```bash
+npm run dev
+```
 
-### Optional
+Open [http://localhost:3000](http://localhost:3000)
 
-| Variable                | Default       | Description                                                                                                                                                     |
-| ----------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `PORT`                  | `3000`        | Server port number                                                                                                                                              |
-| `LOG_LEVEL`             | `info`        | Logging level. Options: `trace`, `debug`, `info`, `warn`, `error`, `fatal`                                                                                      |
-| `NODE_ENV`              | `development` | Environment mode. Set to `production` for JSON logs (no pretty-printing)                                                                                        |
-| `ASSEMBLY_AI_EAGERNESS` | `medium`      | Turn detection sensitivity for speech-to-text. Options: `low` (conservative, allows thinking pauses), `medium` (balanced), `high` (aggressive, quick responses) |
+**For production**:
 
-### Step 4: Run the Application
+```bash
+npm run build
+npm start
+```
+
+### Step 5 (Optional): Set Up Supabase for User Auth
 
-For development:
+Without Supabase, the app works in anonymous mode using localStorage.
+
+**a) Create a Supabase project** at [supabase.com](https://supabase.com)
+
+**b) Push the database schema:**
 
 ```bash
-npm run dev
+npx supabase login
+npx supabase link --project-ref YOUR_PROJECT_REF
+npx supabase db push
 ```
 
-For production:
+Find your project ref in the Supabase dashboard URL: `supabase.com/dashboard/project/YOUR_PROJECT_REF`
+
+**c) Create `frontend/.env.local`:**
 
 ```bash
-npm run build
-npm start
+VITE_SUPABASE_URL=https://YOUR_PROJECT.supabase.co
+VITE_SUPABASE_PUBLISHABLE_KEY=your_anon_key
 ```
 
+Find these in: Supabase Dashboard > Settings > API
+
 ## Repo Structure
 
 ```
 language-learning-node/
 ├── backend/
-│   ├── config/               # Configuration
-│   │   ├── languages.ts      # Language definitions and teacher personas
-│   │   ├── llm.ts            # LLM model configuration
-│   │   └── server.ts         # Server and audio settings
-│   ├── graphs/               # Graph definitions
-│   │   ├── configs/          # Auto-exported graph JSON configs
-│   │   ├── nodes/            # Graph node implementations
-│   │   ├── conversation-graph.ts
-│   │   ├── flashcard-graph.ts
-│   │   └── response-feedback-graph.ts
-│   ├── helpers/              # Helper utilities
-│   │   ├── anki-exporter.ts
-│   │   ├── audio-buffer.ts
-│   │   ├── audio-utils.ts
-│   │   ├── connection-manager.ts
-│   │   ├── feedback-processor.ts
-│   │   ├── flashcard-processor.ts
-│   │   ├── multimodal-stream-manager.ts
-│   │   └── prompt-templates.ts
+│   ├── __tests__/            # Backend unit tests
+│   ├── config/               # Language & server configuration
+│   ├── graphs/               # Inworld Runtime conversation graphs
+│   │   ├── configs/          # Graph JSON configurations
+│   │   └── nodes/            # Custom graph nodes (STT, TTS, etc.)
+│   ├── helpers/              # Audio utils, connection management, etc.
 │   ├── prompts/              # Nunjucks prompt templates
-│   │   ├── conversation.njk
-│   │   ├── flashcard.njk
-│   │   └── response-feedback.njk
-│   ├── types/                # TypeScript type definitions
-│   ├── utils/                # Utility modules
-│   │   └── logger.ts         # Structured logging (pino)
-│   └── server.ts             # Backend server
-├── frontend/                 # React frontend application
-│   ├── public/               # Static assets
+│   ├── services/             # Server components
+│   ├── utils/                # Logger
+│   └── server.ts             # Express + WebSocket server entry point
+├── frontend/
 │   ├── src/
+│   │   ├── __tests__/        # Frontend unit tests
 │   │   ├── components/       # React components
-│   │   ├── context/          # React context providers
+│   │   ├── context/          # App state & auth (React Context)
 │   │   ├── hooks/            # Custom React hooks
-│   │   ├── services/         # Frontend services
-│   │   ├── styles/           # CSS styles
-│   │   └── types/            # TypeScript type definitions
-│   └── index.html
-├── package.json              # Dependencies
-└── LICENSE                   # MIT License
+│   │   ├── services/         # WebSocket client, audio, storage
+│   │   ├── styles/           # CSS
+│   │   └── types/            # TypeScript types
+│   └── vitest.config.ts      # Frontend test config
+├── supabase/                 # Database migrations (optional)
+├── deploy/                   # Deployment configurations
+├── package.json
+└── .env                      # Environment variables
 ```
 
-## Graph Registration
+## Architecture
+
+The app uses a real-time audio streaming architecture:
+
+1. **Frontend** captures microphone audio and streams it via WebSocket
+2. **Backend** processes audio through an Inworld Runtime graph:
+   - AssemblyAI handles speech-to-text with voice activity detection
+   - LLM generates contextual responses in the target language
+   - TTS converts responses back to audio
+3. **Flashcards** are auto-generated from conversation vocabulary
+4. **Response feedback** provides grammar and usage corrections
 
-On server startup, graph JSON configurations are automatically exported to `backend/graphs/configs/`. To register graphs with the Inworld Portal for use with [Experiments](https://docs.inworld.ai/docs/node/guides/experiments):
+## Environment Variables Reference
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `INWORLD_API_KEY` | Yes | Inworld AI Base64 API key |
+| `ASSEMBLY_AI_API_KEY` | Yes | AssemblyAI API key |
+| `PORT` | No | Server port (default: 3000) |
+| `LOG_LEVEL` | No | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
+| `NODE_ENV` | No | `development` or `production` |
+| `ASSEMBLY_AI_EAGERNESS` | No | Turn detection: `low`, `medium`, `high` (default: medium) |
+
+## Testing
+
+Run the test suite to verify core functionality:
+
+```bash
+npm test              # Run all tests
+npm run test:backend  # Backend tests only
+npm run test:frontend # Frontend tests only
+npm run test:watch    # Watch mode for backend
+```
 
-1. Start the server (`npm run dev`)
-2. Find the exported JSON files in `backend/graphs/configs/`
-3. In the [Inworld Portal](https://platform.inworld.ai/), go to **Register Graph**
-4. Enter the graph ID (e.g., `flashcard-generation-graph`)
-5. Click **Create Variant** and upload the corresponding JSON file
+Tests cover critical paths: audio conversion, language configuration, storage persistence, and flashcard deduplication.
 
 ## Troubleshooting
 
diff --git a/backend/__tests__/config/languages.test.ts b/backend/__tests__/config/languages.test.ts
new file mode 100644
index 0000000..426d959
--- /dev/null
+++ b/backend/__tests__/config/languages.test.ts
@@ -0,0 +1,156 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getLanguageConfig,
+  getSupportedLanguageCodes,
+  getLanguageOptions,
+  DEFAULT_LANGUAGE_CODE,
+  SUPPORTED_LANGUAGES,
+} from '../../config/languages.js';
+
+describe('languages config', () => {
+  describe('getLanguageConfig', () => {
+    it('returns Spanish config for "es"', () => {
+      const config = getLanguageConfig('es');
+      expect(config.code).toBe('es');
+      expect(config.name).toBe('Spanish');
+      expect(config.teacherPersona.name).toBe('Señor Gael Herrera');
+    });
+
+    it('returns English config for "en"', () => {
+      const config = getLanguageConfig('en');
+      expect(config.code).toBe('en');
+      expect(config.name).toBe('English');
+      expect(config.ttsConfig.speakerId).toBe('Ashley');
+    });
+
+    it('returns French config for "fr"', () => {
+      const config = getLanguageConfig('fr');
+      expect(config.code).toBe('fr');
+      expect(config.name).toBe('French');
+      expect(config.ttsConfig.speakerId).toBe('Alain');
+    });
+
+    it('returns fallback to Spanish for unknown language code', () => {
+      const config = getLanguageConfig('zz');
+      expect(config.code).toBe('es');
+    });
+
+    it('returns fallback to Spanish for empty string', () => {
+      const config = getLanguageConfig('');
+      expect(config.code).toBe('es');
+    });
+
+    it('has required fields for each supported language', () => {
+      const codes = getSupportedLanguageCodes();
+      for (const code of codes) {
+        const config = getLanguageConfig(code);
+        expect(config.code).toBe(code);
+        expect(config.name).toBeTruthy();
+        expect(config.nativeName).toBeTruthy();
+        expect(config.flag).toBeTruthy();
+        expect(config.sttLanguageCode).toBeTruthy();
+        expect(config.ttsConfig).toBeDefined();
+        expect(config.ttsConfig.speakerId).toBeTruthy();
+        expect(config.ttsConfig.modelId).toBeTruthy();
+        expect(config.teacherPersona).toBeDefined();
+        expect(config.teacherPersona.name).toBeTruthy();
+        expect(config.exampleTopics.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('getSupportedLanguageCodes', () => {
+    it('returns array of supported language codes', () => {
+      const codes = getSupportedLanguageCodes();
+      expect(Array.isArray(codes)).toBe(true);
+      expect(codes.length).toBeGreaterThan(0);
+    });
+
+    it('includes expected languages', () => {
+      const codes = getSupportedLanguageCodes();
+      expect(codes).toContain('es');
+      expect(codes).toContain('en');
+      expect(codes).toContain('fr');
+      expect(codes).toContain('de');
+    });
+
+    it('matches SUPPORTED_LANGUAGES keys', () => {
+      const codes = getSupportedLanguageCodes();
+      expect(codes.length).toBe(Object.keys(SUPPORTED_LANGUAGES).length);
+      for (const code of codes) {
+        expect(SUPPORTED_LANGUAGES[code]).toBeDefined();
+      }
+    });
+  });
+
+  describe('getLanguageOptions', () => {
+    it('returns options with code, name, nativeName, and flag', () => {
+      const options = getLanguageOptions();
+      expect(Array.isArray(options)).toBe(true);
+      expect(options.length).toBeGreaterThan(0);
+
+      for (const option of options) {
+        expect(option.code).toBeTruthy();
+        expect(option.name).toBeTruthy();
+        expect(option.nativeName).toBeTruthy();
+        expect(option.flag).toBeTruthy();
+      }
+    });
+
+    it('returns Spanish with correct properties', () => {
+      const options = getLanguageOptions();
+      const spanish = options.find((o) => o.code === 'es');
+
+      expect(spanish).toBeDefined();
+      expect(spanish!.name).toBe('Spanish');
+      expect(spanish!.nativeName).toBe('Español');
+    });
+
+    it('has same count as supported languages', () => {
+      const options = getLanguageOptions();
+      const codes = getSupportedLanguageCodes();
+      expect(options.length).toBe(codes.length);
+    });
+  });
+
+  describe('DEFAULT_LANGUAGE_CODE', () => {
+    it('is a valid supported language', () => {
+      const codes = getSupportedLanguageCodes();
+      expect(codes).toContain(DEFAULT_LANGUAGE_CODE);
+    });
+
+    it('is Spanish', () => {
+      expect(DEFAULT_LANGUAGE_CODE).toBe('es');
+    });
+  });
+
+  describe('TTS configurations', () => {
+    it('each language has valid TTS config', () => {
+      const codes = getSupportedLanguageCodes();
+      for (const code of codes) {
+        const config = getLanguageConfig(code);
+        expect(config.ttsConfig.speakingRate).toBeGreaterThan(0);
+        expect(config.ttsConfig.temperature).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('teacher personas', () => {
+    it('each language has a teacher with valid age', () => {
+      const codes = getSupportedLanguageCodes();
+      for (const code of codes) {
+        const config = getLanguageConfig(code);
+        expect(config.teacherPersona.age).toBeGreaterThan(20);
+        expect(config.teacherPersona.age).toBeLessThan(100);
+      }
+    });
+
+    it('each language has a teacher with nationality', () => {
+      const codes = getSupportedLanguageCodes();
+      for (const code of codes) {
+        const config = getLanguageConfig(code);
+        expect(config.teacherPersona.nationality).toBeTruthy();
+      }
+    });
+  });
+});
diff --git a/backend/__tests__/helpers/anki-exporter.test.ts b/backend/__tests__/helpers/anki-exporter.test.ts
new file mode 100644
index 0000000..de4dbe3
--- /dev/null
+++ b/backend/__tests__/helpers/anki-exporter.test.ts
@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { AnkiExporter } from '../../helpers/anki-exporter.js';
+import type { Flashcard } from '../../helpers/flashcard-processor.js';
+
+// Helper to create test flashcards
+function createFlashcard(overrides: Partial<Flashcard> = {}): Flashcard {
+  return {
+    id: 'test-id',
+    targetWord: 'hola',
+    english: 'hello',
+    example: 'Hola, ¿cómo estás?',
+    mnemonic: 'Think of "hello" when you wave',
+    timestamp: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('AnkiExporter', () => {
+  const exporter = new AnkiExporter();
+
+  describe('countValidFlashcards', () => {
+    it('counts flashcards with both targetWord and english', () => {
+      const flashcards = [
+        createFlashcard({ targetWord: 'hola', english: 'hello' }),
+        createFlashcard({ targetWord: 'adios', english: 'goodbye' }),
+      ];
+      expect(exporter.countValidFlashcards(flashcards)).toBe(2);
+    });
+
+    it('excludes flashcards missing targetWord', () => {
+      const flashcards = [
+        createFlashcard({ targetWord: 'hola', english: 'hello' }),
+        createFlashcard({ targetWord: '', english: 'missing target' }),
+      ];
+      expect(exporter.countValidFlashcards(flashcards)).toBe(1);
+    });
+
+    it('excludes flashcards missing english', () => {
+      const flashcards = [
+        createFlashcard({ targetWord: 'hola', english: 'hello' }),
+        createFlashcard({ targetWord: 'test', english: '' }),
+      ];
+      expect(exporter.countValidFlashcards(flashcards)).toBe(1);
+    });
+
+    it('excludes flashcards with whitespace-only fields', () => {
+      const flashcards = [
+        createFlashcard({ targetWord: '   ', english: 'hello' }),
+        createFlashcard({ targetWord: 'test', english: '   ' }),
+      ];
+      expect(exporter.countValidFlashcards(flashcards)).toBe(0);
+    });
+
+    it('returns 0 for empty array', () => {
+      expect(exporter.countValidFlashcards([])).toBe(0);
+    });
+
+    it('handles legacy "spanish" field', () => {
+      const flashcards = [
+        {
+          id: '1',
+          spanish: 'hola',
+          targetWord: '',
+          english: 'hello',
+          example: '',
+          mnemonic: '',
+          timestamp: '',
+        } as Flashcard,
+      ];
+      expect(exporter.countValidFlashcards(flashcards)).toBe(1);
+    });
+
+    it('prefers targetWord over spanish when both present', () => {
+      const flashcards = [
+        {
+          id: '1',
+          targetWord: 'bonjour',
+          spanish: 'hola',
+          english: 'hello',
+          example: '',
+          mnemonic: '',
+          timestamp: '',
+        } as unknown as Flashcard,
+      ];
+      // Should count as valid since targetWord is present
+      expect(exporter.countValidFlashcards(flashcards)).toBe(1);
+    });
+  });
+
+  // Note: exportFlashcards tests are skipped because the anki-apkg-export
+  // package has ESM compatibility issues in vitest. The countValidFlashcards
+  // tests above cover the validation logic. The actual export functionality
+  // is tested manually and works in production.
+});
diff --git a/backend/__tests__/helpers/audio-utils.test.ts b/backend/__tests__/helpers/audio-utils.test.ts
new file mode 100644
index 0000000..ccbf994
--- /dev/null
+++ b/backend/__tests__/helpers/audio-utils.test.ts
@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import {
+  float32ToPCM16,
+  pcm16ToFloat32,
+  audioDataToPCM16,
+  decodeBase64ToFloat32,
+  convertToPCM16Base64,
+} from '../../helpers/audio-utils.js';
+
+describe('audio-utils', () => {
+  describe('float32ToPCM16', () => {
+    it('converts silence (0.0) to 0', () => {
+      const input = new Float32Array([0.0, 0.0, 0.0]);
+      const result = float32ToPCM16(input);
+      expect(result).toEqual(new Int16Array([0, 0, 0]));
+    });
+
+    it('converts max positive (1.0) to 32767', () => {
+      const input = new Float32Array([1.0]);
+      const result = float32ToPCM16(input);
+      expect(result[0]).toBe(32767);
+    });
+
+    it('converts max negative (-1.0) to -32768', () => {
+      const input = new Float32Array([-1.0]);
+      const result = float32ToPCM16(input);
+      expect(result[0]).toBe(-32768);
+    });
+
+    it('clamps values outside [-1, 1] range', () => {
+      const input = new Float32Array([2.0, -2.0]);
+      const result = float32ToPCM16(input);
+      expect(result[0]).toBe(32767);
+      expect(result[1]).toBe(-32768);
+    });
+
+    it('converts mid-range values correctly', () => {
+      const input = new Float32Array([0.5, -0.5]);
+      const result = float32ToPCM16(input);
+      // 0.5 * 32767 = 16383.5, rounded to 16383
+      expect(result[0]).toBe(16383);
+      // -0.5 * 32768 = -16384
+      expect(result[1]).toBe(-16384);
+    });
+  });
+
+  describe('audioDataToPCM16', () => {
+    it('converts number array to PCM16', () => {
+      const input = [0.0, 1.0, -1.0];
+      const result = audioDataToPCM16(input);
+      expect(result[0]).toBe(0);
+      expect(result[1]).toBe(32767);
+      expect(result[2]).toBe(-32768);
+    });
+
+    it('converts Float32Array to PCM16', () => {
+      const input = new Float32Array([0.5, -0.5]);
+      const result = audioDataToPCM16(input);
+      expect(result[0]).toBe(16383);
+      expect(result[1]).toBe(-16384);
+    });
+  });
+
+  describe('pcm16ToFloat32', () => {
+    it('converts 0 to 0.0', () => {
+      const input = new Int16Array([0]);
+      const result = pcm16ToFloat32(input);
+      expect(result[0]).toBeCloseTo(0.0);
+    });
+
+    it('converts 32767 to approximately 1.0', () => {
+      const input = new Int16Array([32767]);
+      const result = pcm16ToFloat32(input);
+      expect(result[0]).toBeCloseTo(1.0, 2);
+    });
+
+    it('converts -32768 to -1.0', () => {
+      const input = new Int16Array([-32768]);
+      const result = pcm16ToFloat32(input);
+      expect(result[0]).toBe(-1.0);
+    });
+
+    it('round-trips values correctly', () => {
+      const original = new Float32Array([0.0, 0.5, -0.5, 0.75, -0.75]);
+      const pcm16 = float32ToPCM16(original);
+      const roundTripped = pcm16ToFloat32(pcm16);
+
+      for (let i = 0; i < original.length; i++) {
+        // Allow small precision loss due to quantization
+        expect(roundTripped[i]).toBeCloseTo(original[i], 2);
+      }
+    });
+  });
+
+  describe('decodeBase64ToFloat32', () => {
+    it('decodes base64 audio to Float32Array', () => {
+      // Create a known Float32Array, encode to base64, decode back
+      const original = new Float32Array([0.5, -0.5, 0.0, 1.0]);
+      const buffer = Buffer.from(original.buffer);
+      const base64 = buffer.toString('base64');
+
+      const decoded = decodeBase64ToFloat32(base64);
+
+      expect(decoded.length).toBe(4);
+      expect(decoded[0]).toBeCloseTo(0.5);
+      expect(decoded[1]).toBeCloseTo(-0.5);
+      expect(decoded[2]).toBeCloseTo(0.0);
+      expect(decoded[3]).toBeCloseTo(1.0);
+    });
+
+    it('handles empty base64 string', () => {
+      const decoded = decodeBase64ToFloat32('');
+      expect(decoded.length).toBe(0);
+    });
+  });
+
+  describe('convertToPCM16Base64', () => {
+    it('returns null for undefined input', () => {
+      const result = convertToPCM16Base64(undefined, 16000);
+      expect(result).toBeNull();
+    });
+
+    it('passes through already base64 encoded strings', () => {
+      const base64Input = 'SGVsbG8gV29ybGQ=';
+      const result = convertToPCM16Base64(base64Input, 16000);
+      expect(result).toBe(base64Input);
+    });
+
+    it('converts Float32Array to base64 PCM16', () => {
+      const input = new Float32Array([0.0, 1.0, -1.0]);
+      const result = convertToPCM16Base64(input, 16000);
+
+      expect(result).not.toBeNull();
+      expect(typeof result).toBe('string');
+
+      // Decode and verify the PCM16 values
+      const buffer = Buffer.from(result!, 'base64');
+      const pcm16 = new Int16Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.length / 2
+      );
+      expect(pcm16[0]).toBe(0);
+      expect(pcm16[1]).toBe(32767);
+      expect(pcm16[2]).toBe(-32768);
+    });
+
+    it('converts number array to base64 PCM16', () => {
+      const input = [0.5, -0.5];
+      const result = convertToPCM16Base64(input, 16000);
+
+      expect(result).not.toBeNull();
+
+      const buffer = Buffer.from(result!, 'base64');
+      const pcm16 = new Int16Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.length / 2
+      );
+      expect(pcm16[0]).toBe(16383);
+      expect(pcm16[1]).toBe(-16384);
+    });
+  });
+});
diff --git a/backend/config/languages.ts b/backend/config/languages.ts
index 01a1949..b742202 100644
--- a/backend/config/languages.ts
+++ b/backend/config/languages.ts
@@ -96,7 +96,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     ttsConfig: {
       speakerId: 'Diego',
       modelId: 'inworld-tts-1',
-      speakingRate: 1.1,
+      speakingRate: 1,
       temperature: 1.1,
       languageCode: 'es-MX',
     },
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
index 59ef59d..78379bb 100644
--- a/backend/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -131,7 +131,7 @@
               "config": {
                 "model_id": "inworld-tts-1",
                 "inference": {
-                  "speaking_rate": 1.1,
+                  "speaking_rate": 1,
                   "temperature": 1.1
                 },
                 "postprocessing": {
@@ -251,7 +251,7 @@
             "config": {
               "model_id": "inworld-tts-1",
               "inference": {
-                "speaking_rate": 1.1,
+                "speaking_rate": 1,
                 "temperature": 1.1
               },
               "postprocessing": {
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 82ca2d3..5e4a7c3 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -278,3 +278,29 @@ export class ConversationGraphWrapper {
     });
   }
 }
+
+// Cache for the conversation graph wrapper instance
+let conversationGraphWrapper: ConversationGraphWrapper | null = null;
+
+/**
+ * Get or create the conversation graph wrapper
+ */
+export function getConversationGraph(
+  config: ConversationGraphConfig
+): ConversationGraphWrapper {
+  if (!conversationGraphWrapper) {
+    logger.info('creating_conversation_graph_wrapper');
+    conversationGraphWrapper = ConversationGraphWrapper.create(config);
+  }
+  return conversationGraphWrapper;
+}
+
+/**
+ * Destroy the conversation graph wrapper and clear the cache
+ */
+export async function destroyConversationGraph(): Promise<void> {
+  if (conversationGraphWrapper) {
+    await conversationGraphWrapper.destroy();
+    conversationGraphWrapper = null;
+  }
+}
diff --git a/backend/prompts/conversation.njk b/backend/prompts/conversation.njk
index 4620553..e8d0bc3 100644
--- a/backend/prompts/conversation.njk
+++ b/backend/prompts/conversation.njk
@@ -25,4 +25,4 @@ Previous conversation:
 
 User just said: {{ current_input }}
 
-Please respond naturally and clearly in 1 short sentence (only be more verbose if the user specifically wants it).
\ No newline at end of file
+Please respond naturally and clearly in 1-2 short sentences (only be more verbose if the user specifically wants it).
\ No newline at end of file
diff --git a/backend/prompts/flashcard.njk b/backend/prompts/flashcard.njk
index b60ee9f..82c7c27 100644
--- a/backend/prompts/flashcard.njk
+++ b/backend/prompts/flashcard.njk
@@ -20,10 +20,9 @@ Based on the ongoing conversation between {{studentName}} and {{teacherName}}, g
 
 ## Guidelines
 
-- The word must NOT have been used in the conversation yet
 - The word must be related to the topics used in the conversation
-- The word must be related to the learner's level (if they are sophisticated, so can the word be. but if they are a beginner, the word should be simple or common)
 - The word should be useful to the learner so they can continue the conversation with new vocabulary
+- Avoid cognates
 
 Now, return JSON with the following format:
 
diff --git a/backend/prompts/response-feedback.njk b/backend/prompts/response-feedback.njk
index 3acbad5..96a7378 100644
--- a/backend/prompts/response-feedback.njk
+++ b/backend/prompts/response-feedback.njk
@@ -12,6 +12,7 @@ You are a {{targetLanguage}} language tutor assistant. Your task is to analyze t
 - If the student made any grammar, vocabulary, or pronunciation errors in their {{targetLanguage}}, offer a gentle correction
 - If the student's response was good, offer a brief word of encouragement or a small tip to improve
 - Keep your feedback to exactly ONE sentence in English
+- Don't worry about punctuation or spelling as that is from audio transcription. Instead focus on their word choice or grammar
 - Be encouraging and constructive
 
 Your feedback (one sentence in English):
\ No newline at end of file
diff --git a/backend/server.ts b/backend/server.ts
index 604b69b..dfcafea 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -11,49 +11,35 @@
 // Load environment variables FIRST
 import dotenv from 'dotenv';
 dotenv.config();
+
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync } from 'fs';
-import { mkdir, writeFile } from 'fs/promises';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Basic imports
 import express from 'express';
 import cors from 'cors';
 import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
-import { telemetry, stopInworldRuntime } from '@inworld/runtime';
-import { MetricType } from '@inworld/runtime/telemetry';
-
-// Import new 0.9 components
-import { ConversationGraphWrapper } from './graphs/conversation-graph.js';
-import { ConnectionManager } from './helpers/connection-manager.js';
-import { ConnectionsMap } from './types/index.js';
 
-// Import existing components (still compatible)
-import { FlashcardProcessor } from './helpers/flashcard-processor.js';
-import { FeedbackProcessor } from './helpers/feedback-processor.js';
-import { getFlashcardGraph } from './graphs/flashcard-graph.js';
-import { getResponseFeedbackGraph } from './graphs/response-feedback-graph.js';
-import { AnkiExporter } from './helpers/anki-exporter.js';
-import {
-  getLanguageConfig,
-  getLanguageOptions,
-  DEFAULT_LANGUAGE_CODE,
-} from './config/languages.js';
 import { serverConfig } from './config/server.js';
 import { serverLogger as logger } from './utils/logger.js';
 
+// Import services
+import { initTelemetry } from './services/telemetry.js';
+import { initializeGraph, exportGraphConfigs } from './services/graph-service.js';
+import { setupWebSocketHandlers } from './services/websocket-handler.js';
+import { apiRouter } from './services/api-routes.js';
+import { createGracefulShutdown } from './services/shutdown.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Initialize Express and servers
 const app = express();
 const server = createServer(app);
 const wss = new WebSocketServer({ server });
 
-// Add JSON parsing middleware
+// Middleware
 app.use(express.json());
-
-// Add CORS middleware for Cloud Run deployment
 app.use(
   cors({
     origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
@@ -62,427 +48,16 @@ app.use(
   })
 );
 
-// ============================================================
-// Global State
-// ============================================================
-
-// Shared connections map (used by graph nodes)
-const connections: ConnectionsMap = {};
-
-// Graph wrapper (created once, shared across all connections)
-let graphWrapper: ConversationGraphWrapper | null = null;
-
-// Connection managers per WebSocket
-const connectionManagers = new Map<string, ConnectionManager>();
-const flashcardProcessors = new Map<string, FlashcardProcessor>();
-const feedbackProcessors = new Map<string, FeedbackProcessor>();
-const connectionAttributes = new Map<
-  string,
-  { timezone?: string; userId?: string; languageCode?: string }
->();
-
-// Shutdown flag
-let isShuttingDown = false;
-
-// ============================================================
-// Initialize Telemetry
-// ============================================================
-
-try {
-  const telemetryApiKey = process.env.INWORLD_API_KEY;
-  if (telemetryApiKey) {
-    telemetry.init({
-      apiKey: telemetryApiKey,
-      appName: serverConfig.telemetry.appName,
-      appVersion: serverConfig.telemetry.appVersion,
-    });
-    logger.debug('telemetry_initialized');
-    logger.debug(`appName: ${serverConfig.telemetry.appName}`);
-
-    telemetry.configureMetric({
-      metricType: MetricType.CounterUInt,
-      name: 'flashcard_clicks_total',
-      description: 'Total flashcard clicks',
-      unit: 'clicks',
-    });
-  } else {
-    logger.warn('telemetry_disabled_no_api_key');
-  }
-} catch (error) {
-  logger.error({ err: error }, 'telemetry_init_failed');
-}
-
-// ============================================================
-// Initialize Graph
-// ============================================================
-
-async function initializeGraph(): Promise<void> {
-  const assemblyAIApiKey = process.env.ASSEMBLY_AI_API_KEY;
-  if (!assemblyAIApiKey) {
-    throw new Error('ASSEMBLY_AI_API_KEY environment variable is required');
-  }
-
-  logger.info('creating_conversation_graph');
-  graphWrapper = ConversationGraphWrapper.create({
-    assemblyAIApiKey,
-    connections,
-    defaultLanguageCode: DEFAULT_LANGUAGE_CODE,
-  });
-  logger.info('conversation_graph_created');
-}
-
-async function exportGraphConfigs(): Promise<void> {
-  const configDir = path.join(__dirname, 'graphs/configs');
-
-  if (!existsSync(configDir)) {
-    await mkdir(configDir, { recursive: true });
-  }
-
-  const graphs = [
-    { id: 'flashcard-generation-graph', graph: getFlashcardGraph() },
-    { id: 'response-feedback-graph', graph: getResponseFeedbackGraph() },
-    ...(graphWrapper
-      ? [{ id: 'lang-learning-conversation-graph', graph: graphWrapper.graph }]
-      : []),
-  ];
-
-  for (const { id, graph } of graphs) {
-    const filePath = path.join(configDir, `${id}.json`);
-    await writeFile(filePath, graph.toJSON(), 'utf-8');
-    logger.info({ graphId: id, path: filePath }, 'graph_config_exported');
-  }
-}
-
-// ============================================================
-// WebSocket Connection Handler
-// ============================================================
-
-wss.on('connection', async (ws) => {
-  if (!graphWrapper) {
-    logger.error('graph_not_initialized_rejecting_connection');
-    ws.close(1011, 'Server not ready');
-    return;
-  }
-
-  const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-  logger.info({ connectionId }, 'websocket_connected');
-
-  // Default language is Spanish
-  const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
-
-  // Create connection manager (replaces AudioProcessor)
-  const connectionManager = new ConnectionManager(
-    connectionId,
-    ws,
-    graphWrapper,
-    connections,
-    defaultLanguageCode
-  );
-
-  // Create flashcard processor
-  const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
-
-  // Create feedback processor
-  const feedbackProcessor = new FeedbackProcessor(defaultLanguageCode);
-
-  // Store processors
-  connectionManagers.set(connectionId, connectionManager);
-  flashcardProcessors.set(connectionId, flashcardProcessor);
-  feedbackProcessors.set(connectionId, feedbackProcessor);
-  connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
-
-  // Set up flashcard generation callback
-  connectionManager.setFlashcardCallback(async (messages) => {
-    if (isShuttingDown) {
-      logger.debug(
-        { connectionId },
-        'skipping_flashcard_generation_shutting_down'
-      );
-      return;
-    }
-
-    try {
-      const attrs = connectionAttributes.get(connectionId) || {};
-      const userAttributes: Record<string, string> = {
-        timezone: attrs.timezone || '',
-      };
-
-      const targetingKey = attrs.userId || connectionId;
-      const userContext = {
-        attributes: userAttributes,
-        targetingKey,
-      };
-
-      const flashcards = await flashcardProcessor.generateFlashcards(
-        messages,
-        1,
-        userContext
-      );
-      if (flashcards.length > 0) {
-        ws.send(
-          JSON.stringify({
-            type: 'flashcards_generated',
-            flashcards,
-          })
-        );
-      }
-    } catch (error) {
-      if (!isShuttingDown) {
-        logger.error(
-          { err: error, connectionId },
-          'flashcard_generation_error'
-        );
-      }
-    }
-  });
-
-  // Set up feedback generation callback
-  connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
-    if (isShuttingDown) {
-      logger.debug(
-        { connectionId },
-        'skipping_feedback_generation_shutting_down'
-      );
-      return;
-    }
-
-    try {
-      const attrs = connectionAttributes.get(connectionId) || {};
-      const userAttributes: Record<string, string> = {
-        timezone: attrs.timezone || '',
-      };
-
-      const targetingKey = attrs.userId || connectionId;
-      const userContext = {
-        attributes: userAttributes,
-        targetingKey,
-      };
-
-      const feedback = await feedbackProcessor.generateFeedback(
-        messages,
-        currentTranscript,
-        userContext
-      );
-
-      if (feedback) {
-        ws.send(
-          JSON.stringify({
-            type: 'feedback_generated',
-            messageContent: currentTranscript,
-            feedback,
-          })
-        );
-      }
-    } catch (error) {
-      if (!isShuttingDown) {
-        logger.error({ err: error, connectionId }, 'feedback_generation_error');
-      }
-    }
-  });
+// Initialize telemetry
+initTelemetry();
 
-  // Start the graph for this connection
-  try {
-    await connectionManager.start();
-    logger.info({ connectionId }, 'graph_started');
-  } catch (error) {
-    logger.error({ err: error, connectionId }, 'graph_start_failed');
-    ws.close(1011, 'Failed to start audio processing');
-    return;
-  }
-
-  // Handle incoming messages
-  ws.on('message', (data) => {
-    try {
-      const message = JSON.parse(data.toString());
-
-      if (message.type === 'audio_chunk' && message.audio_data) {
-        // Process audio chunk
-        connectionManager.addAudioChunk(message.audio_data);
-      } else if (message.type === 'reset_flashcards') {
-        const processor = flashcardProcessors.get(connectionId);
-        if (processor) {
-          processor.reset();
-        }
-      } else if (message.type === 'restart_conversation') {
-        // Reset all state
-        connectionManager.reset();
-        flashcardProcessors.get(connectionId)?.reset();
-        logger.info({ connectionId }, 'conversation_restarted');
-      } else if (message.type === 'set_language') {
-        // Handle language change
-        const newLanguageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
-        const attrs = connectionAttributes.get(connectionId) || {};
-
-        if (attrs.languageCode !== newLanguageCode) {
-          logger.info(
-            { connectionId, from: attrs.languageCode, to: newLanguageCode },
-            'language_change'
-          );
-
-          attrs.languageCode = newLanguageCode;
-          connectionAttributes.set(connectionId, attrs);
-
-          const languageConfig = getLanguageConfig(newLanguageCode);
-
-          // Update all processors
-          flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-          feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-          connectionManager.setLanguage(newLanguageCode);
-
-          // Reset conversation on language change
-          connectionManager.reset();
-          flashcardProcessors.get(connectionId)?.reset();
-          feedbackProcessors.get(connectionId)?.reset();
-
-          // Send confirmation
-          ws.send(
-            JSON.stringify({
-              type: 'language_changed',
-              languageCode: newLanguageCode,
-              languageName: languageConfig.name,
-              teacherName: languageConfig.teacherPersona.name,
-            })
-          );
-
-          logger.info(
-            { connectionId, language: languageConfig.name },
-            'language_changed'
-          );
-        }
-      } else if (message.type === 'user_context') {
-        const timezone = message.timezone || message.data?.timezone;
-        const userId = message.userId || message.data?.userId;
-        const languageCode = message.languageCode || message.data?.languageCode;
-        const currentAttrs = connectionAttributes.get(connectionId) || {};
-        connectionAttributes.set(connectionId, {
-          ...currentAttrs,
-          timezone: timezone || currentAttrs.timezone,
-          userId: userId || currentAttrs.userId,
-          languageCode: languageCode || currentAttrs.languageCode,
-        });
-      } else if (message.type === 'flashcard_clicked') {
-        try {
-          const card = message.card || {};
-          const attrs = connectionAttributes.get(connectionId) || {};
-          telemetry.metric.recordCounterUInt('flashcard_clicks_total', 1, {
-            connectionId,
-            cardId: card.id || '',
-            targetWord: card.targetWord || card.spanish || card.word || '',
-            english: card.english || card.translation || '',
-            source: 'ui',
-            timezone: attrs.timezone || '',
-            languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
-          });
-        } catch (error) {
-          logger.error(
-            { err: error, connectionId },
-            'flashcard_click_record_error'
-          );
-        }
-      } else if (message.type === 'text_message' && message.text) {
-        // Handle text input (bypasses audio/STT)
-        connectionManager.sendTextMessage(message.text);
-      } else {
-        logger.debug(
-          { connectionId, messageType: message.type },
-          'received_message'
-        );
-      }
-    } catch (error) {
-      logger.error({ err: error, connectionId }, 'message_processing_error');
-    }
-  });
-
-  ws.on('error', (error) => {
-    logger.error({ err: error, connectionId }, 'websocket_error');
-  });
-
-  ws.on('close', async () => {
-    logger.info({ connectionId }, 'websocket_closed');
-
-    // Clean up connection manager
-    const manager = connectionManagers.get(connectionId);
-    if (manager) {
-      try {
-        await manager.destroy();
-      } catch (error) {
-        logger.error(
-          { err: error, connectionId },
-          'connection_manager_destroy_error'
-        );
-      }
-      connectionManagers.delete(connectionId);
-    }
-
-    // Clean up other processors
-    flashcardProcessors.delete(connectionId);
-    feedbackProcessors.delete(connectionId);
-    connectionAttributes.delete(connectionId);
-  });
-});
-
-// ============================================================
-// API Endpoints
-// ============================================================
-
-// ANKI export endpoint
-app.post('/api/export-anki', async (req, res) => {
-  try {
-    const { flashcards, deckName, languageCode } = req.body;
-
-    if (!flashcards || !Array.isArray(flashcards) || flashcards.length === 0) {
-      res.status(400).json({ error: 'No flashcards provided' });
-      return;
-    }
-
-    const exporter = new AnkiExporter();
-    const validCount = exporter.countValidFlashcards(flashcards);
-
-    if (validCount === 0) {
-      res.status(400).json({ error: 'No valid flashcards to export' });
-      return;
-    }
-
-    const defaultDeckName = `Inworld Language Tutor ${languageCode || 'Language'} Cards`;
-    const apkgBuffer = await exporter.exportFlashcards(
-      flashcards,
-      deckName || defaultDeckName
-    );
-
-    res.setHeader('Content-Type', 'application/octet-stream');
-    res.setHeader(
-      'Content-Disposition',
-      `attachment; filename="${(deckName || defaultDeckName).replace(/[^a-zA-Z0-9]/g, '_')}.apkg"`
-    );
-    res.send(apkgBuffer);
-  } catch (error) {
-    logger.error({ err: error }, 'anki_export_error');
-    res.status(500).json({ error: 'Failed to export Anki deck' });
-  }
-});
-
-// Languages endpoint
-app.get('/api/languages', (_req, res) => {
-  try {
-    const languages = getLanguageOptions();
-    res.json({ languages, defaultLanguage: DEFAULT_LANGUAGE_CODE });
-  } catch (error) {
-    logger.error({ err: error }, 'get_languages_error');
-    res.status(500).json({ error: 'Failed to get languages' });
-  }
-});
-
-// Health check endpoint for Cloud Run
+// API routes
+app.use('/api', apiRouter);
 app.get('/health', (_req, res) => {
-  res
-    .status(200)
-    .json({ status: 'healthy', timestamp: new Date().toISOString() });
+  res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() });
 });
 
-// ============================================================
-// Static Files
-// ============================================================
-
+// Static files
 const frontendPath = path.join(__dirname, '../../frontend');
 const devFrontendPath = path.join(__dirname, '../frontend');
 const staticPath = path.resolve(frontendPath);
@@ -490,10 +65,10 @@ const devStaticPath = path.resolve(devFrontendPath);
 const finalStaticPath = existsSync(devStaticPath) ? devStaticPath : staticPath;
 app.use(express.static(finalStaticPath));
 
-// ============================================================
-// Server Startup
-// ============================================================
+// WebSocket handlers
+setupWebSocketHandlers(wss);
 
+// Server startup
 async function startServer(): Promise<void> {
   try {
     await initializeGraph();
@@ -510,56 +85,7 @@ async function startServer(): Promise<void> {
 
 startServer();
 
-// ============================================================
-// Graceful Shutdown
-// ============================================================
-
-async function gracefulShutdown(): Promise<void> {
-  if (isShuttingDown) return;
-  isShuttingDown = true;
-
-  logger.info('shutdown_initiated');
-
-  try {
-    // Close all WebSocket connections
-    logger.info(
-      { connectionCount: wss.clients.size },
-      'closing_websocket_connections'
-    );
-    wss.clients.forEach((ws) => {
-      if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
-        ws.close();
-      }
-    });
-
-    wss.close();
-
-    // Clean up connection managers
-    for (const manager of connectionManagers.values()) {
-      manager.destroy().catch(() => {});
-    }
-
-    // Clean up graph wrapper
-    if (graphWrapper) {
-      await graphWrapper.destroy();
-    }
-
-    server.close(() => {
-      logger.info('http_server_closed');
-    });
-
-    stopInworldRuntime()
-      .then(() => logger.info('inworld_runtime_stopped'))
-      .catch(() => {});
-
-    logger.info('shutdown_complete');
-  } catch {
-    // Ignore errors during shutdown
-  }
-
-  process.exitCode = 0;
-  process.exit(0);
-}
-
+// Graceful shutdown
+const gracefulShutdown = createGracefulShutdown(server, wss);
 process.on('SIGTERM', gracefulShutdown);
 process.on('SIGINT', gracefulShutdown);
diff --git a/backend/services/api-routes.ts b/backend/services/api-routes.ts
new file mode 100644
index 0000000..4350085
--- /dev/null
+++ b/backend/services/api-routes.ts
@@ -0,0 +1,69 @@
+/**
+ * API Routes
+ *
+ * Express router for REST API endpoints.
+ */
+
+import { Router } from 'express';
+import { AnkiExporter } from '../helpers/anki-exporter.js';
+import {
+  getLanguageOptions,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
+import { serverLogger as logger } from '../utils/logger.js';
+
+export const apiRouter = Router();
+
+// ANKI export endpoint
+apiRouter.post('/export-anki', async (req, res) => {
+  try {
+    const { flashcards, deckName, languageCode } = req.body;
+
+    if (!flashcards || !Array.isArray(flashcards) || flashcards.length === 0) {
+      res.status(400).json({ error: 'No flashcards provided' });
+      return;
+    }
+
+    const exporter = new AnkiExporter();
+    const validCount = exporter.countValidFlashcards(flashcards);
+
+    if (validCount === 0) {
+      res.status(400).json({ error: 'No valid flashcards to export' });
+      return;
+    }
+
+    const defaultDeckName = `Inworld Language Tutor ${languageCode || 'Language'} Cards`;
+    const apkgBuffer = await exporter.exportFlashcards(
+      flashcards,
+      deckName || defaultDeckName
+    );
+
+    res.setHeader('Content-Type', 'application/octet-stream');
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename="${(deckName || defaultDeckName).replace(/[^a-zA-Z0-9]/g, '_')}.apkg"`
+    );
+    res.send(apkgBuffer);
+  } catch (error) {
+    logger.error({ err: error }, 'anki_export_error');
+    res.status(500).json({ error: 'Failed to export Anki deck' });
+  }
+});
+
+// Languages endpoint
+apiRouter.get('/languages', (_req, res) => {
+  try {
+    const languages = getLanguageOptions();
+    res.json({ languages, defaultLanguage: DEFAULT_LANGUAGE_CODE });
+  } catch (error) {
+    logger.error({ err: error }, 'get_languages_error');
+    res.status(500).json({ error: 'Failed to get languages' });
+  }
+});
+
+// Health check endpoint for Cloud Run
+apiRouter.get('/health', (_req, res) => {
+  res
+    .status(200)
+    .json({ status: 'healthy', timestamp: new Date().toISOString() });
+});
diff --git a/backend/services/graph-service.ts b/backend/services/graph-service.ts
new file mode 100644
index 0000000..741ef14
--- /dev/null
+++ b/backend/services/graph-service.ts
@@ -0,0 +1,74 @@
+/**
+ * Graph Service
+ *
+ * Manages graph initialization and configuration export.
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
+
+import {
+  getConversationGraph,
+  destroyConversationGraph,
+  ConversationGraphWrapper,
+} from '../graphs/conversation-graph.js';
+import { getFlashcardGraph } from '../graphs/flashcard-graph.js';
+import { getResponseFeedbackGraph } from '../graphs/response-feedback-graph.js';
+import { DEFAULT_LANGUAGE_CODE } from '../config/languages.js';
+import { serverLogger as logger } from '../utils/logger.js';
+import { connections } from './state.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Reference to the initialized graph wrapper
+let graphWrapper: ConversationGraphWrapper | null = null;
+
+export function getGraphWrapper(): ConversationGraphWrapper | null {
+  return graphWrapper;
+}
+
+export async function initializeGraph(): Promise<void> {
+  const assemblyAIApiKey = process.env.ASSEMBLY_AI_API_KEY;
+  if (!assemblyAIApiKey) {
+    throw new Error('ASSEMBLY_AI_API_KEY environment variable is required');
+  }
+
+  logger.info('initializing_conversation_graph');
+  graphWrapper = getConversationGraph({
+    assemblyAIApiKey,
+    connections,
+    defaultLanguageCode: DEFAULT_LANGUAGE_CODE,
+  });
+  logger.info('conversation_graph_initialized');
+}
+
+export async function exportGraphConfigs(): Promise<void> {
+  // Navigate from services/ to graphs/configs/
+  const configDir = path.join(__dirname, '../graphs/configs');
+
+  if (!existsSync(configDir)) {
+    await mkdir(configDir, { recursive: true });
+  }
+
+  const graphs = [
+    { id: 'flashcard-generation-graph', graph: getFlashcardGraph() },
+    { id: 'response-feedback-graph', graph: getResponseFeedbackGraph() },
+    ...(graphWrapper
+      ? [{ id: 'lang-learning-conversation-graph', graph: graphWrapper.graph }]
+      : []),
+  ];
+
+  for (const { id, graph } of graphs) {
+    const filePath = path.join(configDir, `${id}.json`);
+    await writeFile(filePath, graph.toJSON(), 'utf-8');
+    logger.info({ graphId: id, path: filePath }, 'graph_config_exported');
+  }
+}
+
+export async function destroyGraph(): Promise<void> {
+  await destroyConversationGraph();
+  graphWrapper = null;
+}
diff --git a/backend/services/shutdown.ts b/backend/services/shutdown.ts
new file mode 100644
index 0000000..ca03fbe
--- /dev/null
+++ b/backend/services/shutdown.ts
@@ -0,0 +1,63 @@
+/**
+ * Graceful Shutdown Service
+ *
+ * Handles cleanup of all resources during server shutdown.
+ */
+
+import { Server } from 'http';
+import { WebSocketServer } from 'ws';
+import { stopInworldRuntime } from '@inworld/runtime';
+
+import { serverLogger as logger } from '../utils/logger.js';
+import { connectionManagers, setShuttingDown, isShuttingDown } from './state.js';
+import { destroyGraph } from './graph-service.js';
+
+export function createGracefulShutdown(
+  server: Server,
+  wss: WebSocketServer
+): () => Promise<void> {
+  return async function gracefulShutdown(): Promise<void> {
+    if (isShuttingDown()) return;
+    setShuttingDown(true);
+
+    logger.info('shutdown_initiated');
+
+    try {
+      // Close all WebSocket connections
+      logger.info(
+        { connectionCount: wss.clients.size },
+        'closing_websocket_connections'
+      );
+      wss.clients.forEach((ws) => {
+        if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
+          ws.close();
+        }
+      });
+
+      wss.close();
+
+      // Clean up connection managers
+      for (const manager of connectionManagers.values()) {
+        manager.destroy().catch(() => {});
+      }
+
+      // Clean up graph wrapper
+      await destroyGraph();
+
+      server.close(() => {
+        logger.info('http_server_closed');
+      });
+
+      stopInworldRuntime()
+        .then(() => logger.info('inworld_runtime_stopped'))
+        .catch(() => {});
+
+      logger.info('shutdown_complete');
+    } catch {
+      // Ignore errors during shutdown
+    }
+
+    process.exitCode = 0;
+    process.exit(0);
+  };
+}
diff --git a/backend/services/state.ts b/backend/services/state.ts
new file mode 100644
index 0000000..924fbc5
--- /dev/null
+++ b/backend/services/state.ts
@@ -0,0 +1,33 @@
+/**
+ * Global State Management
+ *
+ * Centralized state for managing connections, processors, and shutdown status.
+ */
+
+import { ConnectionManager } from '../helpers/connection-manager.js';
+import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
+import { FeedbackProcessor } from '../helpers/feedback-processor.js';
+import { ConnectionsMap } from '../types/index.js';
+
+// Shared connections map (used by graph nodes)
+export const connections: ConnectionsMap = {};
+
+// Connection managers per WebSocket
+export const connectionManagers = new Map<string, ConnectionManager>();
+export const flashcardProcessors = new Map<string, FlashcardProcessor>();
+export const feedbackProcessors = new Map<string, FeedbackProcessor>();
+export const connectionAttributes = new Map<
+  string,
+  { timezone?: string; userId?: string; languageCode?: string }
+>();
+
+// Shutdown flag
+let _isShuttingDown = false;
+
+export function isShuttingDown(): boolean {
+  return _isShuttingDown;
+}
+
+export function setShuttingDown(value: boolean): void {
+  _isShuttingDown = value;
+}
diff --git a/backend/services/telemetry.ts b/backend/services/telemetry.ts
new file mode 100644
index 0000000..b7f1018
--- /dev/null
+++ b/backend/services/telemetry.ts
@@ -0,0 +1,36 @@
+/**
+ * Telemetry Service
+ *
+ * Initializes and configures Inworld telemetry.
+ */
+
+import { telemetry } from '@inworld/runtime';
+import { MetricType } from '@inworld/runtime/telemetry';
+import { serverConfig } from '../config/server.js';
+import { serverLogger as logger } from '../utils/logger.js';
+
+export function initTelemetry(): void {
+  try {
+    const telemetryApiKey = process.env.INWORLD_API_KEY;
+    if (telemetryApiKey) {
+      telemetry.init({
+        apiKey: telemetryApiKey,
+        appName: serverConfig.telemetry.appName,
+        appVersion: serverConfig.telemetry.appVersion,
+      });
+      logger.debug('telemetry_initialized');
+      logger.debug(`appName: ${serverConfig.telemetry.appName}`);
+
+      telemetry.configureMetric({
+        metricType: MetricType.CounterUInt,
+        name: 'flashcard_clicks_total',
+        description: 'Total flashcard clicks',
+        unit: 'clicks',
+      });
+    } else {
+      logger.warn('telemetry_disabled_no_api_key');
+    }
+  } catch (error) {
+    logger.error({ err: error }, 'telemetry_init_failed');
+  }
+}
diff --git a/backend/services/websocket-handler.ts b/backend/services/websocket-handler.ts
new file mode 100644
index 0000000..1e38400
--- /dev/null
+++ b/backend/services/websocket-handler.ts
@@ -0,0 +1,365 @@
+/**
+ * WebSocket Handler
+ *
+ * Manages WebSocket connections and message processing.
+ */
+
+import { WebSocketServer, WebSocket } from 'ws';
+import { telemetry } from '@inworld/runtime';
+
+import { ConnectionManager } from '../helpers/connection-manager.js';
+import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
+import { FeedbackProcessor } from '../helpers/feedback-processor.js';
+import {
+  getLanguageConfig,
+  getSupportedLanguageCodes,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
+import { serverLogger as logger } from '../utils/logger.js';
+
+import {
+  connections,
+  connectionManagers,
+  flashcardProcessors,
+  feedbackProcessors,
+  connectionAttributes,
+  isShuttingDown,
+} from './state.js';
+import { getGraphWrapper } from './graph-service.js';
+
+export function setupWebSocketHandlers(wss: WebSocketServer): void {
+  wss.on('connection', async (ws: WebSocket) => {
+    const graphWrapper = getGraphWrapper();
+    if (!graphWrapper) {
+      logger.error('graph_not_initialized_rejecting_connection');
+      ws.close(1011, 'Server not ready');
+      return;
+    }
+
+    const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    logger.info({ connectionId }, 'websocket_connected');
+
+    // Default language is Spanish
+    const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
+
+    // Create connection manager (replaces AudioProcessor)
+    const connectionManager = new ConnectionManager(
+      connectionId,
+      ws,
+      graphWrapper,
+      connections,
+      defaultLanguageCode
+    );
+
+    // Create flashcard processor
+    const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
+
+    // Create feedback processor
+    const feedbackProcessor = new FeedbackProcessor(defaultLanguageCode);
+
+    // Store processors
+    connectionManagers.set(connectionId, connectionManager);
+    flashcardProcessors.set(connectionId, flashcardProcessor);
+    feedbackProcessors.set(connectionId, feedbackProcessor);
+    connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
+
+    // Set up flashcard generation callback
+    connectionManager.setFlashcardCallback(async (messages) => {
+      if (isShuttingDown()) {
+        logger.debug(
+          { connectionId },
+          'skipping_flashcard_generation_shutting_down'
+        );
+        return;
+      }
+
+      try {
+        const attrs = connectionAttributes.get(connectionId) || {};
+        const userAttributes: Record<string, string> = {
+          timezone: attrs.timezone || '',
+        };
+
+        const targetingKey = attrs.userId || connectionId;
+        const userContext = {
+          attributes: userAttributes,
+          targetingKey,
+        };
+
+        const flashcards = await flashcardProcessor.generateFlashcards(
+          messages,
+          1,
+          userContext
+        );
+        if (flashcards.length > 0) {
+          ws.send(
+            JSON.stringify({
+              type: 'flashcards_generated',
+              flashcards,
+            })
+          );
+        }
+      } catch (error) {
+        if (!isShuttingDown()) {
+          logger.error(
+            { err: error, connectionId },
+            'flashcard_generation_error'
+          );
+        }
+      }
+    });
+
+    // Set up feedback generation callback
+    connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
+      if (isShuttingDown()) {
+        logger.debug(
+          { connectionId },
+          'skipping_feedback_generation_shutting_down'
+        );
+        return;
+      }
+
+      try {
+        const attrs = connectionAttributes.get(connectionId) || {};
+        const userAttributes: Record<string, string> = {
+          timezone: attrs.timezone || '',
+        };
+
+        const targetingKey = attrs.userId || connectionId;
+        const userContext = {
+          attributes: userAttributes,
+          targetingKey,
+        };
+
+        const feedback = await feedbackProcessor.generateFeedback(
+          messages,
+          currentTranscript,
+          userContext
+        );
+
+        if (feedback) {
+          ws.send(
+            JSON.stringify({
+              type: 'feedback_generated',
+              messageContent: currentTranscript,
+              feedback,
+            })
+          );
+        }
+      } catch (error) {
+        if (!isShuttingDown()) {
+          logger.error({ err: error, connectionId }, 'feedback_generation_error');
+        }
+      }
+    });
+
+    // Start the graph for this connection
+    try {
+      await connectionManager.start();
+      logger.info({ connectionId }, 'graph_started');
+    } catch (error) {
+      logger.error({ err: error, connectionId }, 'graph_start_failed');
+      ws.close(1011, 'Failed to start audio processing');
+      return;
+    }
+
+    // Handle incoming messages
+    ws.on('message', (data) => {
+      handleMessage(connectionId, ws, connectionManager, data);
+    });
+
+    ws.on('error', (error) => {
+      logger.error({ err: error, connectionId }, 'websocket_error');
+    });
+
+    ws.on('close', async () => {
+      logger.info({ connectionId }, 'websocket_closed');
+
+      // Clean up connection manager
+      const manager = connectionManagers.get(connectionId);
+      if (manager) {
+        try {
+          await manager.destroy();
+        } catch (error) {
+          logger.error(
+            { err: error, connectionId },
+            'connection_manager_destroy_error'
+          );
+        }
+        connectionManagers.delete(connectionId);
+      }
+
+      // Clean up other processors
+      flashcardProcessors.delete(connectionId);
+      feedbackProcessors.delete(connectionId);
+      connectionAttributes.delete(connectionId);
+    });
+  });
+}
+
+function handleMessage(
+  connectionId: string,
+  ws: WebSocket,
+  connectionManager: ConnectionManager,
+  data: Buffer | ArrayBuffer | Buffer[]
+): void {
+  try {
+    const message = JSON.parse(data.toString());
+
+    if (message.type === 'audio_chunk' && message.audio_data) {
+      // Process audio chunk
+      connectionManager.addAudioChunk(message.audio_data);
+    } else if (message.type === 'reset_flashcards') {
+      const processor = flashcardProcessors.get(connectionId);
+      if (processor) {
+        processor.reset();
+      }
+    } else if (message.type === 'conversation_context_reset') {
+      // Reset backend state when switching conversations
+      connectionManager.reset();
+      flashcardProcessors.get(connectionId)?.reset();
+      logger.info({ connectionId }, 'conversation_context_reset');
+    } else if (message.type === 'set_language') {
+      handleLanguageChange(connectionId, ws, connectionManager, message);
+    } else if (message.type === 'user_context') {
+      handleUserContext(connectionId, message);
+    } else if (message.type === 'flashcard_clicked') {
+      handleFlashcardClicked(connectionId, message);
+    } else if (message.type === 'text_message') {
+      handleTextMessage(connectionId, ws, connectionManager, message);
+    } else {
+      logger.debug(
+        { connectionId, messageType: message.type },
+        'received_message'
+      );
+    }
+  } catch (error) {
+    logger.error({ err: error, connectionId }, 'message_processing_error');
+  }
+}
+
+function handleLanguageChange(
+  connectionId: string,
+  ws: WebSocket,
+  connectionManager: ConnectionManager,
+  message: { languageCode?: string }
+): void {
+  const requestedCode = message.languageCode;
+  const supportedCodes = getSupportedLanguageCodes();
+
+  let newLanguageCode = DEFAULT_LANGUAGE_CODE;
+  if (requestedCode && supportedCodes.includes(requestedCode)) {
+    newLanguageCode = requestedCode;
+  } else if (requestedCode) {
+    logger.warn(
+      { connectionId, invalidCode: requestedCode, fallback: DEFAULT_LANGUAGE_CODE },
+      'invalid_language_code_using_default'
+    );
+  }
+
+  const attrs = connectionAttributes.get(connectionId) || {};
+
+  if (attrs.languageCode !== newLanguageCode) {
+    logger.info(
+      { connectionId, from: attrs.languageCode, to: newLanguageCode },
+      'language_change'
+    );
+
+    attrs.languageCode = newLanguageCode;
+    connectionAttributes.set(connectionId, attrs);
+
+    const languageConfig = getLanguageConfig(newLanguageCode);
+
+    // Update all processors
+    flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+    feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+    connectionManager.setLanguage(newLanguageCode);
+
+    // Reset conversation on language change
+    connectionManager.reset();
+    flashcardProcessors.get(connectionId)?.reset();
+    feedbackProcessors.get(connectionId)?.reset();
+
+    // Send confirmation
+    ws.send(
+      JSON.stringify({
+        type: 'language_changed',
+        languageCode: newLanguageCode,
+        languageName: languageConfig.name,
+        teacherName: languageConfig.teacherPersona.name,
+      })
+    );
+
+    logger.info(
+      { connectionId, language: languageConfig.name },
+      'language_changed'
+    );
+  }
+}
+
+function handleUserContext(
+  connectionId: string,
+  message: {
+    timezone?: string;
+    userId?: string;
+    languageCode?: string;
+    data?: { timezone?: string; userId?: string; languageCode?: string };
+  }
+): void {
+  const timezone = message.timezone || message.data?.timezone;
+  const userId = message.userId || message.data?.userId;
+  const languageCode = message.languageCode || message.data?.languageCode;
+  const currentAttrs = connectionAttributes.get(connectionId) || {};
+  connectionAttributes.set(connectionId, {
+    ...currentAttrs,
+    timezone: timezone || currentAttrs.timezone,
+    userId: userId || currentAttrs.userId,
+    languageCode: languageCode || currentAttrs.languageCode,
+  });
+}
+
+function handleFlashcardClicked(
+  connectionId: string,
+  message: { card?: { id?: string; targetWord?: string; spanish?: string; word?: string; english?: string; translation?: string } }
+): void {
+  const card = message.card;
+  if (!card || typeof card !== 'object') {
+    logger.debug({ connectionId }, 'flashcard_clicked_missing_card_data');
+    return;
+  }
+  try {
+    const attrs = connectionAttributes.get(connectionId) || {};
+    telemetry.metric.recordCounterUInt('flashcard_clicks_total', 1, {
+      connectionId,
+      cardId: card.id || '',
+      targetWord: card.targetWord || card.spanish || card.word || '',
+      english: card.english || card.translation || '',
+      source: 'ui',
+      timezone: attrs.timezone || '',
+      languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
+    });
+  } catch (error) {
+    logger.error(
+      { err: error, connectionId },
+      'flashcard_click_record_error'
+    );
+  }
+}
+
+function handleTextMessage(
+  connectionId: string,
+  ws: WebSocket,
+  connectionManager: ConnectionManager,
+  message: { text?: string }
+): void {
+  const text = message.text;
+  if (typeof text !== 'string' || text.trim().length === 0) {
+    logger.debug({ connectionId }, 'empty_or_invalid_text_message_ignored');
+    return;
+  }
+  if (text.length > 200) {
+    logger.warn({ connectionId, length: text.length }, 'text_message_too_long');
+    ws.send(JSON.stringify({ type: 'error', message: 'Text message too long (max 200 chars)' }));
+    return;
+  }
+  connectionManager.sendTextMessage(text.trim());
+}
diff --git a/backend/vitest.config.ts b/backend/vitest.config.ts
new file mode 100644
index 0000000..3a80879
--- /dev/null
+++ b/backend/vitest.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    root: './backend',
+    include: ['__tests__/**/*.test.ts'],
+    coverage: {
+      reporter: ['text', 'lcov'],
+      exclude: ['node_modules', '__tests__', 'graphs/nodes/**'],
+    },
+  },
+});
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 805265b..295597c 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -8,6 +8,7 @@
       "name": "frontend",
       "version": "0.0.0",
       "dependencies": {
+        "@supabase/supabase-js": "^2.89.0",
         "react": "^19.2.0",
         "react-dom": "^19.2.0"
       },
@@ -21,11 +22,34 @@
         "eslint-plugin-react-hooks": "^7.0.1",
         "eslint-plugin-react-refresh": "^0.4.24",
         "globals": "^16.5.0",
+        "jsdom": "^25.0.0",
         "typescript": "~5.9.3",
         "typescript-eslint": "^8.46.4",
-        "vite": "^7.2.4"
+        "vite": "^7.2.4",
+        "vitest": "^2.1.0"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
+      "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.3",
+        "@csstools/css-color-parser": "^3.0.9",
+        "@csstools/css-parser-algorithms": "^3.0.4",
+        "@csstools/css-tokenizer": "^3.0.3",
+        "lru-cache": "^10.4.3"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
@@ -308,6 +332,121 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.27.2",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
@@ -1324,6 +1463,86 @@
         "win32"
       ]
     },
+    "node_modules/@supabase/auth-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.89.0.tgz",
+      "integrity": "sha512-wiWZdz8WMad8LQdJMWYDZ2SJtZP5MwMqzQq3ehtW2ngiI3UTgbKiFrvMUUS3KADiVlk4LiGfODB2mrYx7w2f8w==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/functions-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.89.0.tgz",
+      "integrity": "sha512-XEueaC5gMe5NufNYfBh9kPwJlP5M2f+Ogr8rvhmRDAZNHgY6mI35RCkYDijd92pMcNM7g8pUUJov93UGUnqfyw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/postgrest-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.89.0.tgz",
+      "integrity": "sha512-/b0fKrxV9i7RNOEXMno/I1862RsYhuUo+Q6m6z3ar1f4ulTMXnDfv0y4YYxK2POcgrOXQOgKYQx1eArybyNvtg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/realtime-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.89.0.tgz",
+      "integrity": "sha512-aMOvfDb2a52u6PX6jrrjvACHXGV3zsOlWRzZsTIOAJa0hOVvRp01AwC1+nLTGUzxzezejrYeCX+KnnM1xHdl+w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/phoenix": "^1.6.6",
+        "@types/ws": "^8.18.1",
+        "tslib": "2.8.1",
+        "ws": "^8.18.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/storage-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.89.0.tgz",
+      "integrity": "sha512-6zKcXofk/M/4Eato7iqpRh+B+vnxeiTumCIP+Tz26xEqIiywzD9JxHq+udRrDuv6hXE+pmetvJd8n5wcf4MFRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "iceberg-js": "^0.8.1",
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/supabase-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.89.0.tgz",
+      "integrity": "sha512-KlaRwSfFA0fD73PYVMHj5/iXFtQGCcX7PSx0FdQwYEEw9b2wqM7GxadY+5YwcmuEhalmjFB/YvqaoNVF+sWUlg==",
+      "license": "MIT",
+      "dependencies": {
+        "@supabase/auth-js": "2.89.0",
+        "@supabase/functions-js": "2.89.0",
+        "@supabase/postgrest-js": "2.89.0",
+        "@supabase/realtime-js": "2.89.0",
+        "@supabase/storage-js": "2.89.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
       "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
@@ -1387,12 +1606,17 @@
       "version": "24.10.4",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.4.tgz",
       "integrity": "sha512-vnDVpYPMzs4wunl27jHrfmwojOGKya0xyM3sH+UE5iv5uPS6vX7UIoh6m+vQc5LGBq52HBKPIn/zcSZVzeDEZg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~7.16.0"
       }
     },
+    "node_modules/@types/phoenix": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/@types/phoenix/-/phoenix-1.6.7.tgz",
+      "integrity": "sha512-oN9ive//QSBkf19rfDv45M7eZPi0eEXylht2OLEXicu5b4KoQ1OzXIw+xDSGWxSxe1JmepRR/ZH283vsu518/Q==",
+      "license": "MIT"
+    },
     "node_modules/@types/react": {
       "version": "19.2.7",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.7.tgz",
@@ -1413,6 +1637,15 @@
         "@types/react": "^19.2.0"
       }
     },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.51.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.51.0.tgz",
@@ -1703,6 +1936,92 @@
         "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
       }
     },
+    "node_modules/@vitest/expect": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
+      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
+      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
+      "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "2.1.9",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
+      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
+      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^3.0.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
+      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "loupe": "^3.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
@@ -1726,6 +2045,16 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/ajv": {
       "version": "6.12.6",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
@@ -1766,6 +2095,23 @@
       "dev": true,
       "license": "Python-2.0"
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -1828,6 +2174,30 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -1859,6 +2229,23 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -1876,6 +2263,16 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/check-error": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -1896,6 +2293,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -1925,6 +2335,27 @@
         "node": ">= 8"
       }
     },
+    "node_modules/cssstyle": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",
+      "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^3.2.0",
+        "rrweb-cssom": "^0.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/cssstyle/node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/csstype": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
@@ -1932,6 +2363,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/data-urls": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",
+      "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -1950,6 +2395,23 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -1957,13 +2419,107 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.267",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz",
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.267",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz",
       "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==",
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/esbuild": {
       "version": "0.27.2",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
@@ -2203,6 +2759,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -2213,6 +2779,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -2303,6 +2879,23 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2318,6 +2911,16 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/gensync": {
       "version": "1.0.0-beta.2",
       "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
@@ -2328,6 +2931,45 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
@@ -2354,6 +2996,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -2364,6 +3019,48 @@
         "node": ">=8"
       }
     },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/hermes-estree": {
       "version": "0.25.1",
       "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
@@ -2381,6 +3078,69 @@
         "hermes-estree": "0.25.1"
       }
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/iceberg-js": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
+      "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -2441,6 +3201,13 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -2468,6 +3235,47 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/jsdom": {
+      "version": "25.0.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-25.0.1.tgz",
+      "integrity": "sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssstyle": "^4.1.0",
+        "data-urls": "^5.0.0",
+        "decimal.js": "^10.4.3",
+        "form-data": "^4.0.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.5",
+        "is-potential-custom-element-name": "^1.0.1",
+        "nwsapi": "^2.2.12",
+        "parse5": "^7.1.2",
+        "rrweb-cssom": "^0.7.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^5.0.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^7.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.0.0",
+        "ws": "^8.18.0",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "canvas": "^2.11.2"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/jsesc": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
@@ -2562,6 +3370,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -2572,6 +3387,49 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/minimatch": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -2625,6 +3483,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/nwsapi": {
+      "version": "2.2.23",
+      "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.23.tgz",
+      "integrity": "sha512-7wfH4sLbt4M0gCDzGE6vzQBo0bfTKjU7Sfpqy/7gs1qBfYz2vEJH6vXcBKpO3+6Yu1telwd0t9HpyOoLEQQbIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -2688,6 +3553,19 @@
         "node": ">=6"
       }
     },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -2708,6 +3586,23 @@
         "node": ">=8"
       }
     },
+    "node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -2860,6 +3755,33 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/rrweb-cssom": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.7.1.tgz",
+      "integrity": "sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -2899,6 +3821,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -2909,6 +3838,20 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -2935,13 +3878,34 @@
         "node": ">=8"
       }
     },
-    "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
+      "license": "MIT"
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
         "fdir": "^6.5.0",
         "picomatch": "^4.0.3"
       },
@@ -2952,6 +3916,82 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
+      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
+      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",
+      "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^6.1.86"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",
+      "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tough-cookie": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
+      "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^6.1.32"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.3.0.tgz",
@@ -2965,6 +4005,12 @@
         "typescript": ">=4.8.4"
       }
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -3020,7 +4066,6 @@
       "version": "7.16.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
       "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/update-browserslist-db": {
@@ -3139,32 +4184,1244 @@
         }
       }
     },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+    "node_modules/vite-node": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
+      "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "isexe": "^2.0.0"
+        "cac": "^6.7.14",
+        "debug": "^4.3.7",
+        "es-module-lexer": "^1.5.4",
+        "pathe": "^1.1.2",
+        "vite": "^5.0.0"
       },
       "bin": {
-        "node-which": "bin/node-which"
+        "vite-node": "vite-node.mjs"
       },
       "engines": {
-        "node": ">= 8"
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/word-wrap": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+    "node_modules/vite-node/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
       "dev": true,
       "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
+    "node_modules/vite-node/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite-node/node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/vite-node/node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
+      "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "2.1.9",
+        "@vitest/mocker": "2.1.9",
+        "@vitest/pretty-format": "^2.1.9",
+        "@vitest/runner": "2.1.9",
+        "@vitest/snapshot": "2.1.9",
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "debug": "^4.3.7",
+        "expect-type": "^1.1.0",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2",
+        "std-env": "^3.8.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.1",
+        "tinypool": "^1.0.1",
+        "tinyrainbow": "^1.2.0",
+        "vite": "^5.0.0",
+        "vite-node": "2.1.9",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "2.1.9",
+        "@vitest/ui": "2.1.9",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitest/node_modules/@vitest/mocker": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
+      "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.12"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/vitest/node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index eded7cd..12b6841 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -7,14 +7,18 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
+    "@supabase/supabase-js": "^2.89.0",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "jsdom": "^25.0.0",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -25,6 +29,7 @@
     "globals": "^16.5.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
-    "vite": "^7.2.4"
+    "vite": "^7.2.4",
+    "vitest": "^2.1.0"
   }
 }
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index e6f1697..22e6ddd 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,24 +1,30 @@
 import { AppProvider } from './context/AppContext';
 import { Header } from './components/Header';
+import { Sidebar } from './components/Sidebar';
 import { ChatSection } from './components/ChatSection';
 import { FlashcardsSection } from './components/FlashcardsSection';
 import './styles/main.css';
 
 function AppContent() {
   return (
-    <>
+    <div className="app-wrapper">
       <Header />
-      <main className="main">
-        <div className="container">
-          <div className="app-grid">
-            <ChatSection />
-            <FlashcardsSection />
-          </div>
+      <div className="app-layout">
+        <Sidebar />
+        <div className="app-main">
+          <main className="main">
+            <div className="container">
+              <div className="app-grid">
+                <ChatSection />
+                <FlashcardsSection />
+              </div>
+            </div>
+          </main>
+          {/* Hidden audio element for iOS compatibility */}
+          <audio id="iosAudioElement" style={{ display: 'none' }} playsInline />
         </div>
-      </main>
-      {/* Hidden audio element for iOS compatibility */}
-      <audio id="iosAudioElement" style={{ display: 'none' }} playsInline />
-    </>
+      </div>
+    </div>
   );
 }
 
diff --git a/frontend/src/__tests__/services/Storage.test.ts b/frontend/src/__tests__/services/Storage.test.ts
new file mode 100644
index 0000000..4093391
--- /dev/null
+++ b/frontend/src/__tests__/services/Storage.test.ts
@@ -0,0 +1,346 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Storage } from '../../services/Storage';
+
+describe('Storage', () => {
+  let storage: Storage;
+
+  beforeEach(() => {
+    storage = new Storage();
+  });
+
+  describe('getLanguage / saveLanguage', () => {
+    it('returns "es" as default', () => {
+      expect(storage.getLanguage()).toBe('es');
+    });
+
+    it('returns saved language', () => {
+      storage.saveLanguage('fr');
+      expect(storage.getLanguage()).toBe('fr');
+    });
+
+    it('persists language across instances', () => {
+      storage.saveLanguage('de');
+      const newStorage = new Storage();
+      expect(newStorage.getLanguage()).toBe('de');
+    });
+  });
+
+  describe('getOrCreateUserId', () => {
+    it('creates a user ID on first call', () => {
+      const id = storage.getOrCreateUserId();
+      expect(id).toBeTruthy();
+      expect(typeof id).toBe('string');
+    });
+
+    it('returns same ID on subsequent calls', () => {
+      const id1 = storage.getOrCreateUserId();
+      const id2 = storage.getOrCreateUserId();
+      expect(id1).toBe(id2);
+    });
+
+    it('persists user ID across instances', () => {
+      const id1 = storage.getOrCreateUserId();
+      const newStorage = new Storage();
+      const id2 = newStorage.getOrCreateUserId();
+      expect(id1).toBe(id2);
+    });
+  });
+
+  describe('addMessage', () => {
+    it('adds message to conversation history', () => {
+      storage.addMessage('user', 'Hello');
+      const history = storage.getConversationHistory();
+
+      expect(history.messages.length).toBe(1);
+      expect(history.messages[0].role).toBe('user');
+      expect(history.messages[0].content).toBe('Hello');
+    });
+
+    it('adds multiple messages in order', () => {
+      storage.addMessage('user', 'Hello');
+      storage.addMessage('assistant', 'Hi there!');
+      const history = storage.getConversationHistory();
+
+      expect(history.messages.length).toBe(2);
+      expect(history.messages[0].content).toBe('Hello');
+      expect(history.messages[1].content).toBe('Hi there!');
+    });
+
+    it('includes timestamp on messages', () => {
+      storage.addMessage('user', 'Hello');
+      const history = storage.getConversationHistory();
+
+      expect(history.messages[0].timestamp).toBeTruthy();
+      // Verify it's a valid ISO date string
+      expect(() => new Date(history.messages[0].timestamp)).not.toThrow();
+    });
+
+    it('truncates to 80 messages max', () => {
+      // Add 85 messages
+      for (let i = 0; i < 85; i++) {
+        storage.addMessage('user', `Message ${i}`);
+      }
+
+      const history = storage.getConversationHistory();
+      expect(history.messages.length).toBe(80);
+      // First 5 should be truncated, so first message is "Message 5"
+      expect(history.messages[0].content).toBe('Message 5');
+      // Last message should be "Message 84"
+      expect(history.messages[79].content).toBe('Message 84');
+    });
+  });
+
+  describe('clearConversation', () => {
+    it('clears all messages', () => {
+      storage.addMessage('user', 'Hello');
+      storage.addMessage('assistant', 'Hi!');
+      storage.clearConversation();
+
+      const history = storage.getConversationHistory();
+      expect(history.messages.length).toBe(0);
+    });
+  });
+
+  describe('createConversation', () => {
+    it('creates conversation with unique ID', () => {
+      const conv = storage.createConversation('es');
+      expect(conv.id).toBeTruthy();
+      expect(conv.languageCode).toBe('es');
+    });
+
+    it('creates conversation with title containing random numbers', () => {
+      const conv = storage.createConversation('es');
+      expect(conv.title).toMatch(/^Chat \d{5}$/);
+    });
+
+    it('creates multiple conversations with different IDs', () => {
+      const conv1 = storage.createConversation('es');
+      const conv2 = storage.createConversation('es');
+      expect(conv1.id).not.toBe(conv2.id);
+    });
+
+    it('adds conversation to list', () => {
+      storage.createConversation('es');
+      const list = storage.getConversationList('es');
+      expect(list.length).toBe(1);
+    });
+
+    it('adds new conversations at beginning of list', () => {
+      const conv1 = storage.createConversation('es');
+      const conv2 = storage.createConversation('es');
+      const list = storage.getConversationList('es');
+
+      expect(list[0].id).toBe(conv2.id);
+      expect(list[1].id).toBe(conv1.id);
+    });
+  });
+
+  describe('deleteConversation', () => {
+    it('removes conversation from list', () => {
+      const conv = storage.createConversation('es');
+      storage.deleteConversation(conv.id, 'es');
+
+      const list = storage.getConversationList('es');
+      expect(list.length).toBe(0);
+    });
+
+    it('removes conversation data', () => {
+      const conv = storage.createConversation('es');
+      storage.deleteConversation(conv.id, 'es');
+
+      const data = storage.getConversation(conv.id);
+      expect(data).toBeNull();
+    });
+  });
+
+  describe('renameConversation', () => {
+    it('updates conversation title', () => {
+      const conv = storage.createConversation('es');
+      storage.renameConversation(conv.id, 'My Spanish Chat', 'es');
+
+      const list = storage.getConversationList('es');
+      expect(list[0].title).toBe('My Spanish Chat');
+    });
+  });
+
+  describe('saveConversation / getConversation', () => {
+    it('saves and retrieves conversation messages', () => {
+      const conv = storage.createConversation('es');
+      const messages = [
+        { role: 'user' as const, content: 'Hola', timestamp: new Date().toISOString() },
+        { role: 'assistant' as const, content: '¡Hola!', timestamp: new Date().toISOString() },
+      ];
+
+      storage.saveConversation(conv.id, messages, 'es');
+      const data = storage.getConversation(conv.id);
+
+      expect(data).not.toBeNull();
+      expect(data!.messages.length).toBe(2);
+      expect(data!.messages[0].content).toBe('Hola');
+    });
+  });
+
+  describe('addFlashcards', () => {
+    it('adds flashcards to storage', () => {
+      const cards = [
+        { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+      ];
+      const result = storage.addFlashcards(cards as any, 'es');
+
+      expect(result.length).toBe(1);
+      expect(result[0].targetWord).toBe('hola');
+    });
+
+    it('deduplicates flashcards by targetWord', () => {
+      const cards1 = [
+        { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+      ];
+      storage.addFlashcards(cards1 as any, 'es');
+
+      const cards2 = [
+        { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+        { targetWord: 'adios', english: 'goodbye', example: '', mnemonic: '' },
+      ];
+      const result = storage.addFlashcards(cards2 as any, 'es');
+
+      // Should only have 2 cards (hola + adios), not 3
+      expect(result.length).toBe(2);
+    });
+
+    it('is case-insensitive for duplicate detection', () => {
+      const cards1 = [
+        { targetWord: 'Hola', english: 'hello', example: '', mnemonic: '' },
+      ];
+      storage.addFlashcards(cards1 as any, 'es');
+
+      const cards2 = [
+        { targetWord: 'hola', english: 'hello again', example: '', mnemonic: '' },
+      ];
+      const result = storage.addFlashcards(cards2 as any, 'es');
+
+      expect(result.length).toBe(1);
+      expect(result[0].targetWord).toBe('Hola');
+    });
+
+    it('adds language code to flashcards', () => {
+      const cards = [
+        { targetWord: 'bonjour', english: 'hello', example: '', mnemonic: '' },
+      ];
+      const result = storage.addFlashcards(cards as any, 'fr');
+
+      expect(result[0].languageCode).toBe('fr');
+    });
+
+    it('handles legacy spanish field', () => {
+      const cards = [
+        { spanish: 'hola', english: 'hello', example: '', mnemonic: '' },
+      ];
+      const result = storage.addFlashcards(cards as any, 'es');
+
+      expect(result[0].targetWord).toBe('hola');
+    });
+
+    it('limits to 100 flashcards per language', () => {
+      // Add 110 flashcards
+      for (let i = 0; i < 110; i++) {
+        storage.addFlashcards(
+          [{ targetWord: `word${i}`, english: `translation${i}`, example: '', mnemonic: '' }] as any,
+          'es'
+        );
+      }
+
+      const flashcards = storage.getFlashcards('es');
+      expect(flashcards.length).toBe(100);
+    });
+  });
+
+  describe('clearFlashcards', () => {
+    it('clears flashcards for a language', () => {
+      storage.addFlashcards(
+        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        'es'
+      );
+      storage.clearFlashcards('es');
+
+      const flashcards = storage.getFlashcards('es');
+      expect(flashcards.length).toBe(0);
+    });
+
+    it('does not affect flashcards for other languages', () => {
+      storage.addFlashcards(
+        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        'es'
+      );
+      storage.addFlashcards(
+        [{ targetWord: 'bonjour', english: 'hello', example: '', mnemonic: '' }] as any,
+        'fr'
+      );
+
+      storage.clearFlashcards('es');
+
+      expect(storage.getFlashcards('es').length).toBe(0);
+      expect(storage.getFlashcards('fr').length).toBe(1);
+    });
+  });
+
+  describe('per-conversation flashcards', () => {
+    it('stores flashcards per conversation', () => {
+      const conv = storage.createConversation('es');
+      const cards = [
+        { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+      ];
+
+      storage.addFlashcardsForConversation(conv.id, cards as any, 'es');
+      const result = storage.getFlashcardsForConversation(conv.id);
+
+      expect(result.length).toBe(1);
+      expect(result[0].conversationId).toBe(conv.id);
+    });
+
+    it('isolates flashcards between conversations', () => {
+      const conv1 = storage.createConversation('es');
+      const conv2 = storage.createConversation('es');
+
+      storage.addFlashcardsForConversation(
+        conv1.id,
+        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        'es'
+      );
+      storage.addFlashcardsForConversation(
+        conv2.id,
+        [{ targetWord: 'adios', english: 'goodbye', example: '', mnemonic: '' }] as any,
+        'es'
+      );
+
+      expect(storage.getFlashcardsForConversation(conv1.id).length).toBe(1);
+      expect(storage.getFlashcardsForConversation(conv1.id)[0].targetWord).toBe('hola');
+      expect(storage.getFlashcardsForConversation(conv2.id).length).toBe(1);
+      expect(storage.getFlashcardsForConversation(conv2.id)[0].targetWord).toBe('adios');
+    });
+  });
+
+  describe('getAllConversations', () => {
+    it('returns conversations across all languages', () => {
+      storage.createConversation('es');
+      storage.createConversation('fr');
+      storage.createConversation('de');
+
+      const all = storage.getAllConversations();
+      expect(all.length).toBe(3);
+    });
+
+    it('sorts by updatedAt descending', () => {
+      const conv1 = storage.createConversation('es');
+
+      // Wait a tiny bit to ensure different timestamps
+      const conv2 = storage.createConversation('fr');
+
+      // Update conv1 to make it more recent
+      storage.saveConversation(conv1.id, [], 'es');
+
+      const all = storage.getAllConversations();
+      // conv1 was updated more recently
+      expect(all[0].id).toBe(conv1.id);
+    });
+  });
+});
diff --git a/frontend/src/__tests__/setup.ts b/frontend/src/__tests__/setup.ts
new file mode 100644
index 0000000..9365ffa
--- /dev/null
+++ b/frontend/src/__tests__/setup.ts
@@ -0,0 +1,36 @@
+/// <reference types="vitest/globals" />
+
+// Mock localStorage
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+  return {
+    getItem: (key: string) => store[key] || null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      store = {};
+    },
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: (i: number) => Object.keys(store)[i] || null,
+  };
+})();
+
+Object.defineProperty(global, 'localStorage', { value: localStorageMock });
+
+// Mock crypto.randomUUID
+Object.defineProperty(global, 'crypto', {
+  value: {
+    randomUUID: () => `test-uuid-${Math.random().toString(36).slice(2, 10)}`,
+  },
+});
+
+// Reset localStorage before each test
+beforeEach(() => {
+  localStorageMock.clear();
+});
diff --git a/frontend/src/components/ChatSection.tsx b/frontend/src/components/ChatSection.tsx
index 1d62c8c..012d489 100644
--- a/frontend/src/components/ChatSection.tsx
+++ b/frontend/src/components/ChatSection.tsx
@@ -11,8 +11,7 @@ import { Message } from './Message';
 import { StreamingMessage } from './StreamingMessage';
 
 export function ChatSection() {
-  const { state, toggleRecording, restartConversation, sendTextMessage } =
-    useApp();
+  const { state, toggleRecording, sendTextMessage } = useApp();
   const [textInput, setTextInput] = useState('');
   const {
     chatHistory,
@@ -23,8 +22,20 @@ export function ChatSection() {
     speechDetected,
     connectionStatus,
     currentResponseId,
+    currentLanguage,
+    currentConversationId,
+    conversations,
+    availableLanguages,
   } = state;
 
+  // Get the flag for the current conversation or selected language
+  const getCurrentFlag = (): string => {
+    const currentConversation = conversations.find(c => c.id === currentConversationId);
+    const langCode = currentConversation?.languageCode || currentLanguage;
+    const lang = availableLanguages.find(l => l.code === langCode);
+    return lang?.flag || '🌐';
+  };
+
   const messagesContainerRef = useRef<HTMLDivElement>(null);
   const responseIdRef = useRef<string | null>(null);
 
@@ -96,51 +107,39 @@ export function ChatSection() {
   return (
     <section className="chat-section">
       <div className="section-header">
-        <h2>Conversation</h2>
-        <div className="button-group">
-          <button
-            className="restart-button"
-            id="restartButton"
-            onClick={restartConversation}
-            disabled={!isConnected}
-            title="Restart conversation"
-          >
-            <svg
-              width="20"
-              height="20"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              strokeWidth="1"
-              strokeLinecap="round"
-              strokeLinejoin="round"
-            >
-              <path d="M21.5 2v6h-6M21.5 8A9.5 9.5 0 0 0 12 2.5 9.5 9.5 0 0 0 2.5 12 9.5 9.5 0 0 0 12 21.5 9.5 9.5 0 0 0 21.5 12" />
-            </svg>
-          </button>
-          <button
-            className={`mic-button ${isRecording ? 'recording' : ''}`}
-            id="micButton"
-            onClick={toggleRecording}
-            disabled={!isConnected}
+        <h2>
+          Conversation
+          <span className="section-header-flag">{getCurrentFlag()}</span>
+        </h2>
+        <button
+          className={`mic-button ${isRecording ? 'recording' : ''}`}
+          id="micButton"
+          onClick={toggleRecording}
+          disabled={!isConnected}
+        >
+          <svg
+            width="24"
+            height="24"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
           >
-            <svg
-              width="24"
-              height="24"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-            >
-              <path d="M12 1a4 4 0 0 0-4 4v6a4 4 0 0 0 8 0V5a4 4 0 0 0-4-4z" />
-              <path d="M19 10v1a7 7 0 0 1-14 0v-1" />
-              <line x1="12" y1="19" x2="12" y2="23" />
-              <line x1="8" y1="23" x2="16" y2="23" />
-            </svg>
-          </button>
-        </div>
+            <path d="M12 1a4 4 0 0 0-4 4v6a4 4 0 0 0 8 0V5a4 4 0 0 0-4-4z" />
+            <path d="M19 10v1a7 7 0 0 1-14 0v-1" />
+            <line x1="12" y1="19" x2="12" y2="23" />
+            <line x1="8" y1="23" x2="16" y2="23" />
+          </svg>
+        </button>
       </div>
       <div className="chat-container">
         <div className="messages" id="messages" ref={messagesContainerRef}>
+          {/* Loading overlay when not connected */}
+          {connectionStatus !== 'connected' && (
+            <div className="chat-loading">
+              <div className="chat-loading-spinner" />
+            </div>
+          )}
+
           {/* Render existing conversation history */}
           {chatHistory.map((message, index) => (
             <Message key={`msg-${index}`} message={message} />
@@ -185,6 +184,7 @@ export function ChatSection() {
             onChange={(e) => setTextInput(e.target.value)}
             onKeyDown={handleKeyDown}
             disabled={!isConnected}
+            maxLength={200}
           />
           <button
             type="submit"
diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index f9b6ad9..620b55a 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -1,8 +1,20 @@
+import { useState, useRef, useEffect } from 'react';
 import { useApp } from '../context/AppContext';
+import { useAuth } from '../context/AuthContext';
 
 export function Header() {
-  const { state, changeLanguage } = useApp();
-  const { connectionStatus, currentLanguage, availableLanguages } = state;
+  const { state, toggleSidebar } = useApp();
+  const { connectionStatus } = state;
+  const { user, isLoading, isConfigured, signUp, signIn, signOut } = useAuth();
+
+  const [showMenu, setShowMenu] = useState(false);
+  const [showAuthForm, setShowAuthForm] = useState(false);
+  const [isSignUp, setIsSignUp] = useState(false);
+  const [email, setEmail] = useState('');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+  const menuRef = useRef<HTMLDivElement>(null);
 
   const statusMessages: Record<string, string> = {
     connecting: 'Connecting...',
@@ -10,38 +22,167 @@ export function Header() {
     disconnected: 'Disconnected',
   };
 
-  const handleLanguageChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
-    const newLanguage = e.target.value;
-    if (newLanguage !== currentLanguage) {
-      changeLanguage(newLanguage);
+  // Close menus when clicking outside
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        setShowMenu(false);
+        setShowAuthForm(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => document.removeEventListener('mousedown', handleClickOutside);
+  }, []);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+    setSubmitting(true);
+
+    const result = isSignUp
+      ? await signUp(email, password)
+      : await signIn(email, password);
+
+    setSubmitting(false);
+
+    if (result.error) {
+      setError(result.error);
+    } else {
+      setShowAuthForm(false);
+      setEmail('');
+      setPassword('');
     }
   };
 
+  const toggleAuthMode = () => {
+    setIsSignUp(!isSignUp);
+    setError(null);
+  };
+
+  const handleSignOut = async () => {
+    await signOut();
+    setShowMenu(false);
+  };
+
   return (
     <header className="header">
-      <div className="container">
-        <h1 className="logo">Inworld Language Tutor</h1>
-        <div className="header-controls">
-          <div className="language-selector">
-            <select
-              id="languageSelect"
-              className="language-dropdown"
-              value={currentLanguage}
-              onChange={handleLanguageChange}
-              disabled={connectionStatus !== 'connected'}
+      <div className="header-content">
+        <div className="header-left">
+          <button
+            className="menu-toggle"
+            onClick={toggleSidebar}
+            aria-label="Toggle sidebar"
+          >
+            <svg
+              width="24"
+              height="24"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              strokeWidth="2"
+              strokeLinecap="round"
+              strokeLinejoin="round"
             >
-              {availableLanguages.map((lang) => (
-                <option key={lang.code} value={lang.code}>
-                  {lang.flag} {lang.name}
-                </option>
-              ))}
-            </select>
-          </div>
-          <div className="status-indicator">
-            <span className={`status-dot ${connectionStatus}`} id="statusDot" />
-            <span className="status-text" id="statusText">
-              {statusMessages[connectionStatus] || 'Unknown'}
-            </span>
+              <line x1="3" y1="12" x2="21" y2="12" />
+              <line x1="3" y1="6" x2="21" y2="6" />
+              <line x1="3" y1="18" x2="21" y2="18" />
+            </svg>
+          </button>
+          <h1 className="header-logo">Inworld Language Tutor</h1>
+        </div>
+
+        <div className="header-right">
+          {/* Settings Menu */}
+          <div ref={menuRef} style={{ position: 'relative' }}>
+            <button
+              className="logo-menu-button"
+              onClick={() => setShowMenu(!showMenu)}
+              aria-label="Open menu"
+            >
+              <img src="/favicon.svg" alt="Menu" className="logo-icon" />
+            </button>
+
+            {showMenu && (
+              <div className="header-dropdown">
+                {/* Connection Status */}
+                <div className="dropdown-item dropdown-status">
+                  <span className={`status-dot ${connectionStatus}`} />
+                  <span>{statusMessages[connectionStatus] || 'Unknown'}</span>
+                </div>
+
+                {/* Auth Section */}
+                {isConfigured && (
+                <>
+                  <div className="dropdown-divider" />
+                  {isLoading ? (
+                    <div className="dropdown-item dropdown-loading">Loading...</div>
+                  ) : user ? (
+                    <>
+                      <div className="dropdown-item dropdown-user">
+                        <span className="dropdown-label">Signed in as</span>
+                        <span className="dropdown-email">{user.email}</span>
+                      </div>
+                      <button
+                        className="dropdown-item dropdown-button"
+                        onClick={handleSignOut}
+                      >
+                        Sign Out
+                      </button>
+                    </>
+                  ) : !showAuthForm ? (
+                    <button
+                      className="dropdown-item dropdown-button"
+                      onClick={() => setShowAuthForm(true)}
+                    >
+                      Sign In
+                    </button>
+                  ) : (
+                    <form onSubmit={handleSubmit} className="dropdown-auth-form">
+                      <div className="dropdown-auth-header">
+                        {isSignUp ? 'Create Account' : 'Sign In'}
+                      </div>
+                      {error && <div className="dropdown-auth-error">{error}</div>}
+                      <input
+                        type="email"
+                        placeholder="Email"
+                        value={email}
+                        onChange={(e) => setEmail(e.target.value)}
+                        required
+                        autoComplete="email"
+                        className="dropdown-input"
+                      />
+                      <input
+                        type="password"
+                        placeholder="Password"
+                        value={password}
+                        onChange={(e) => setPassword(e.target.value)}
+                        required
+                        minLength={6}
+                        autoComplete={isSignUp ? 'new-password' : 'current-password'}
+                        className="dropdown-input"
+                      />
+                      <button
+                        type="submit"
+                        className="dropdown-submit"
+                        disabled={submitting}
+                      >
+                        {submitting ? '...' : isSignUp ? 'Create Account' : 'Sign In'}
+                      </button>
+                      <button
+                        type="button"
+                        className="dropdown-toggle-auth"
+                        onClick={toggleAuthMode}
+                      >
+                        {isSignUp
+                          ? 'Have an account? Sign In'
+                          : 'Need an account? Sign Up'}
+                      </button>
+                    </form>
+                  )}
+                </>
+              )}
+            </div>
+          )}
           </div>
         </div>
       </div>
diff --git a/frontend/src/components/Sidebar.tsx b/frontend/src/components/Sidebar.tsx
new file mode 100644
index 0000000..e70823d
--- /dev/null
+++ b/frontend/src/components/Sidebar.tsx
@@ -0,0 +1,259 @@
+import { useState, useRef, useEffect } from 'react';
+import { useApp } from '../context/AppContext';
+
+export function Sidebar() {
+  const {
+    state,
+    selectConversation,
+    createNewConversation,
+    deleteConversation,
+    renameConversation,
+    toggleSidebar,
+    changeLanguage,
+  } = useApp();
+  const { conversations, currentConversationId, sidebarOpen, availableLanguages, currentLanguage } = state;
+
+  // Helper to get flag for a language code
+  const getFlag = (languageCode: string): string => {
+    const lang = availableLanguages.find((l) => l.code === languageCode);
+    return lang?.flag || '';
+  };
+
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [editValue, setEditValue] = useState('');
+  const [showLangMenu, setShowLangMenu] = useState(false);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const langMenuRef = useRef<HTMLDivElement>(null);
+
+  const currentLang = availableLanguages.find(l => l.code === currentLanguage);
+
+  // Focus input when editing starts
+  useEffect(() => {
+    if (editingId && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [editingId]);
+
+  // Close language menu when clicking outside
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (langMenuRef.current && !langMenuRef.current.contains(event.target as Node)) {
+        setShowLangMenu(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => document.removeEventListener('mousedown', handleClickOutside);
+  }, []);
+
+  const handleLanguageSelect = (langCode: string) => {
+    if (langCode !== currentLanguage) {
+      changeLanguage(langCode);
+    }
+    setShowLangMenu(false);
+  };
+
+  const startEditing = (conversationId: string, currentTitle: string) => {
+    setEditingId(conversationId);
+    setEditValue(currentTitle);
+  };
+
+  const saveEdit = () => {
+    if (editingId && editValue.trim()) {
+      renameConversation(editingId, editValue.trim());
+    }
+    setEditingId(null);
+    setEditValue('');
+  };
+
+  const cancelEdit = () => {
+    setEditingId(null);
+    setEditValue('');
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      saveEdit();
+    } else if (e.key === 'Escape') {
+      cancelEdit();
+    }
+  };
+
+  return (
+    <>
+      {/* Overlay for mobile */}
+      {sidebarOpen && (
+        <div className="sidebar-overlay" onClick={toggleSidebar} />
+      )}
+
+      <aside className={`sidebar ${sidebarOpen ? 'open' : ''}`}>
+        <div className="sidebar-header">
+          <div className="new-chat-wrapper" ref={langMenuRef}>
+            <button
+              className="new-chat-button"
+              onClick={createNewConversation}
+              title="Start a new conversation"
+            >
+              <svg
+                width="16"
+                height="16"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="2"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              >
+                <path d="M12 5v14M5 12h14" />
+              </svg>
+              New chat
+            </button>
+            <button
+              className="new-chat-lang-button"
+              onClick={() => setShowLangMenu(!showLangMenu)}
+              title="Select language for new chat"
+            >
+              <span className="lang-flag">{currentLang?.flag || '🌐'}</span>
+              <svg
+                width="12"
+                height="12"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="2"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              >
+                <path d="M6 9l6 6 6-6" />
+              </svg>
+            </button>
+            {showLangMenu && (
+              <div className="new-chat-lang-dropdown">
+                {availableLanguages.map((lang) => (
+                  <button
+                    key={lang.code}
+                    className={`lang-option ${lang.code === currentLanguage ? 'active' : ''}`}
+                    onClick={() => handleLanguageSelect(lang.code)}
+                  >
+                    <span className="lang-flag">{lang.flag}</span>
+                    <span className="lang-name">{lang.name}</span>
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+          <button
+            className="sidebar-close-button"
+            onClick={toggleSidebar}
+            title="Close sidebar"
+          >
+            <svg
+              width="20"
+              height="20"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              strokeWidth="2"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            >
+              <path d="M18 6L6 18M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+
+        <div className="sidebar-conversations">
+          {conversations.length === 0 ? (
+            <div className="sidebar-empty">
+              <p>No conversations yet</p>
+              <p className="sidebar-empty-hint">
+                Start a new chat to begin learning!
+              </p>
+            </div>
+          ) : (
+            <ul className="conversation-list">
+              {conversations.map((conversation) => (
+                <li
+                  key={conversation.id}
+                  className={`conversation-item ${
+                    conversation.id === currentConversationId ? 'active' : ''
+                  }`}
+                >
+                  {editingId === conversation.id ? (
+                    <div className="conversation-edit">
+                      <input
+                        ref={inputRef}
+                        type="text"
+                        className="conversation-edit-input"
+                        value={editValue}
+                        onChange={(e) => setEditValue(e.target.value)}
+                        onBlur={saveEdit}
+                        onKeyDown={handleKeyDown}
+                      />
+                    </div>
+                  ) : (
+                    <>
+                      <button
+                        className="conversation-button"
+                        onClick={() => selectConversation(conversation.id)}
+                      >
+                        <span className="conversation-flag-left">{getFlag(conversation.languageCode)}</span>
+                        <span className="conversation-title">{conversation.title}</span>
+                      </button>
+                      <div className="conversation-actions">
+                        <button
+                          className="conversation-action-btn"
+                          onClick={(e) => {
+                            e.stopPropagation();
+                            startEditing(conversation.id, conversation.title);
+                          }}
+                          title="Rename conversation"
+                        >
+                          <svg
+                            width="14"
+                            height="14"
+                            viewBox="0 0 24 24"
+                            fill="none"
+                            stroke="currentColor"
+                            strokeWidth="2"
+                            strokeLinecap="round"
+                            strokeLinejoin="round"
+                          >
+                            <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
+                            <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
+                          </svg>
+                        </button>
+                        <button
+                          className="conversation-action-btn conversation-delete"
+                          onClick={(e) => {
+                            e.stopPropagation();
+                            deleteConversation(conversation.id);
+                          }}
+                          title="Delete conversation"
+                        >
+                          <svg
+                            width="14"
+                            height="14"
+                            viewBox="0 0 24 24"
+                            fill="none"
+                            stroke="currentColor"
+                            strokeWidth="2"
+                            strokeLinecap="round"
+                            strokeLinejoin="round"
+                          >
+                            <path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" />
+                          </svg>
+                        </button>
+                      </div>
+                    </>
+                  )}
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      </aside>
+    </>
+  );
+}
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index da708e1..45bcc56 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -15,11 +15,13 @@ import type {
   ConnectionStatus,
   AudioStreamData,
   FeedbackGeneratedPayload,
+  ConversationSummary,
 } from '../types';
-import { Storage } from '../services/Storage';
+import { HybridStorage } from '../services/HybridStorage';
 import { WebSocketClient } from '../services/WebSocketClient';
 import { AudioHandler } from '../services/AudioHandler';
 import { AudioPlayer } from '../services/AudioPlayer';
+import { useAuth } from './AuthContext';
 
 // Helper to determine WebSocket URL for Cloud Run deployment
 const getWebSocketUrl = (): string => {
@@ -61,10 +63,16 @@ type AppAction =
       payload: { messageContent: string; feedback: string };
     }
   | { type: 'RESET_STREAMING_STATE' }
-  | { type: 'RESET_CONVERSATION' };
+  | { type: 'RESET_CONVERSATION' }
+  | { type: 'SET_CONVERSATIONS'; payload: ConversationSummary[] }
+  | { type: 'SET_CURRENT_CONVERSATION_ID'; payload: string | null }
+  | { type: 'SET_SIDEBAR_OPEN'; payload: boolean }
+  | { type: 'ADD_CONVERSATION'; payload: ConversationSummary }
+  | { type: 'REMOVE_CONVERSATION'; payload: string }
+  | { type: 'RENAME_CONVERSATION'; payload: { id: string; title: string } };
 
 // Initial state
-const createInitialState = (storage: Storage): AppState => ({
+const createInitialState = (storage: HybridStorage): AppState => ({
   connectionStatus: 'connecting',
   currentLanguage: storage.getLanguage(),
   availableLanguages: [],
@@ -79,6 +87,9 @@ const createInitialState = (storage: Storage): AppState => ({
   flashcards: [],
   feedbackMap: {},
   userId: storage.getOrCreateUserId(),
+  conversations: [],
+  currentConversationId: null,
+  sidebarOpen: false,
 });
 
 // Reducer
@@ -153,6 +164,28 @@ function appReducer(state: AppState, action: AppAction): AppState {
         currentResponseId: null,
         speechDetected: false,
       };
+    case 'SET_CONVERSATIONS':
+      return { ...state, conversations: action.payload };
+    case 'SET_CURRENT_CONVERSATION_ID':
+      return { ...state, currentConversationId: action.payload };
+    case 'SET_SIDEBAR_OPEN':
+      return { ...state, sidebarOpen: action.payload };
+    case 'ADD_CONVERSATION':
+      return { ...state, conversations: [action.payload, ...state.conversations] };
+    case 'REMOVE_CONVERSATION':
+      return {
+        ...state,
+        conversations: state.conversations.filter((c) => c.id !== action.payload),
+      };
+    case 'RENAME_CONVERSATION':
+      return {
+        ...state,
+        conversations: state.conversations.map((c) =>
+          c.id === action.payload.id
+            ? { ...c, title: action.payload.title, updatedAt: new Date().toISOString() }
+            : c
+        ),
+      };
     default:
       return state;
   }
@@ -162,16 +195,21 @@ function appReducer(state: AppState, action: AppAction): AppState {
 interface AppContextType {
   state: AppState;
   dispatch: React.Dispatch<AppAction>;
-  storage: Storage;
+  storage: HybridStorage;
   wsClient: WebSocketClient;
   audioHandler: AudioHandler;
   audioPlayer: AudioPlayer;
   // Actions
   toggleRecording: () => Promise<void>;
-  restartConversation: () => void;
   changeLanguage: (newLanguage: string) => void;
   handleInterrupt: () => void;
   sendTextMessage: (text: string) => void;
+  // Conversation actions
+  selectConversation: (conversationId: string) => void;
+  createNewConversation: () => void;
+  deleteConversation: (conversationId: string) => void;
+  renameConversation: (conversationId: string, newTitle: string) => void;
+  toggleSidebar: () => void;
 }
 
 const AppContext = createContext<AppContextType | null>(null);
@@ -182,10 +220,12 @@ interface AppProviderProps {
 }
 
 export function AppProvider({ children }: AppProviderProps) {
-  const storageRef = useRef(new Storage());
+  const { supabase, user } = useAuth();
+  const storageRef = useRef(new HybridStorage());
   const wsClientRef = useRef(new WebSocketClient(getWebSocketUrl()));
   const audioHandlerRef = useRef(new AudioHandler());
   const audioPlayerRef = useRef(new AudioPlayer());
+  const hasMigratedRef = useRef(false);
 
   const [state, dispatch] = useReducer(
     appReducer,
@@ -197,16 +237,62 @@ export function AppProvider({ children }: AppProviderProps) {
   const stateRef = useRef(state);
   stateRef.current = state;
 
+  // Connect/disconnect Supabase based on auth state
+  useEffect(() => {
+    const storage = storageRef.current;
+
+    if (supabase && user) {
+      storage.setSupabaseClient(supabase, user.id);
+
+      // Sync data on login
+      if (!hasMigratedRef.current) {
+        hasMigratedRef.current = true;
+        const languages = stateRef.current.availableLanguages.map((l) => l.code);
+        const langsToSync = languages.length > 0 ? languages : [stateRef.current.currentLanguage];
+
+        // First try to sync FROM Supabase (existing user on new device)
+        // Then migrate any local data TO Supabase
+        storage.syncFromSupabase(langsToSync).then(({ conversations }) => {
+          // If user has conversations in Supabase, reload the UI state
+          const currentLang = stateRef.current.currentLanguage;
+          const remoteConvos = conversations.get(currentLang);
+          if (remoteConvos && remoteConvos.length > 0) {
+            dispatch({ type: 'SET_CONVERSATIONS', payload: remoteConvos });
+            // Load the most recent conversation
+            const mostRecent = remoteConvos[0];
+            dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: mostRecent.id });
+            const convData = storage.getConversation(mostRecent.id);
+            if (convData) {
+              const chatHistory = convData.messages.map((m) => ({
+                role: m.role === 'user' ? 'learner' : 'teacher',
+                content: m.content,
+              })) as ChatMessage[];
+              dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+            }
+          }
+          // Also migrate any local data that isn't in Supabase yet
+          return storage.migrateToSupabase(langsToSync);
+        }).catch(console.error);
+      }
+    } else {
+      storage.clearSupabaseClient();
+      hasMigratedRef.current = false;
+    }
+  }, [supabase, user]);
+
   const pendingLLMResponseRef = useRef<string | null>(null);
   const lastPendingTranscriptionRef = useRef<string | null>(null);
   // Track the last processed pair to prevent duplicate additions
   const lastProcessedPairRef = useRef<{ user: string; teacher: string } | null>(
     null
   );
+  // Queue flashcards when conversation doesn't exist yet (race condition fix)
+  const pendingFlashcardsRef = useRef<Flashcard[]>([]);
 
   // Refs for callbacks to avoid effect dependency issues
   const handleInterruptRef = useRef<() => void>(() => {});
   const checkAndUpdateConversationRef = useRef<() => void>(() => {});
+  const processPendingFlashcardsRef = useRef<(conversationId: string) => void>(() => {});
 
   // Initialize audio player
   useEffect(() => {
@@ -216,12 +302,63 @@ export function AppProvider({ children }: AppProviderProps) {
     };
   }, []);
 
-  // Load initial state
+  // Load initial state (conversations across all languages)
   useEffect(() => {
     const storage = storageRef.current;
-    const flashcards = storage.getFlashcards(state.currentLanguage);
-    dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
-  }, [state.currentLanguage]);
+
+    // Load ALL conversations across all languages
+    const allConversations = storage.getAllConversations();
+    dispatch({ type: 'SET_CONVERSATIONS', payload: allConversations });
+
+    // Load current conversation or use the most recent one
+    let currentId = storage.getCurrentConversationId(state.currentLanguage);
+    if (!currentId && allConversations.length > 0) {
+      currentId = allConversations[0].id;
+      // Update language to match the most recent conversation
+      const mostRecentConvo = allConversations[0];
+      if (mostRecentConvo.languageCode !== state.currentLanguage) {
+        dispatch({ type: 'SET_LANGUAGE', payload: mostRecentConvo.languageCode });
+        storage.saveLanguage(mostRecentConvo.languageCode);
+      }
+      storage.setCurrentConversationId(mostRecentConvo.languageCode, currentId);
+    }
+
+    if (currentId) {
+      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: currentId });
+      const conversationData = storage.getConversation(currentId);
+      if (conversationData) {
+        // Convert backend format to UI format
+        const chatHistory = conversationData.messages.map((m) => ({
+          role: m.role === 'user' ? 'learner' : 'teacher',
+          content: m.content,
+        })) as ChatMessage[];
+        dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+
+        // Load flashcards for this specific conversation
+        const flashcards = storage.getFlashcardsForConversation(currentId);
+        dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+      }
+    } else {
+      // No conversations yet - clear flashcards
+      dispatch({ type: 'SET_FLASHCARDS', payload: [] });
+    }
+  }, []); // Run only once on mount
+
+  // Save chat history to current conversation when it changes
+  useEffect(() => {
+    const storage = storageRef.current;
+    const currentId = stateRef.current.currentConversationId;
+    const currentLang = stateRef.current.currentLanguage;
+
+    if (currentId && state.chatHistory.length > 0) {
+      const messages = state.chatHistory.map((m) => ({
+        role: m.role === 'learner' ? 'user' : 'assistant',
+        content: m.content,
+        timestamp: new Date().toISOString(),
+      })) as import('../types').ConversationMessage[];
+      storage.saveConversation(currentId, messages, currentLang);
+    }
+  }, [state.chatHistory]);
 
   // Fetch available languages
   useEffect(() => {
@@ -267,6 +404,26 @@ export function AppProvider({ children }: AppProviderProps) {
     const storage = storageRef.current;
     const wsClient = wsClientRef.current;
 
+    // Track conversation info (may be newly created or from state)
+    let conversationId = currentState.currentConversationId;
+    let conversationTitle: string | null = null;
+
+    // Auto-create conversation if none exists and we're about to add messages
+    if (!conversationId && (pendingTranscription || pendingLLMResponse)) {
+      const newConversation = storage.createConversation(currentState.currentLanguage);
+      conversationId = newConversation.id;
+      conversationTitle = newConversation.title;
+      dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
+      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
+      storage.setCurrentConversationId(currentState.currentLanguage, newConversation.id);
+      // Process any flashcards that arrived before conversation was created
+      processPendingFlashcardsRef.current(newConversation.id);
+    } else if (conversationId) {
+      // Get title from existing conversation in state
+      const currentConvo = currentState.conversations.find((c) => c.id === conversationId);
+      conversationTitle = currentConvo?.title || null;
+    }
+
     const lastUserMessage = currentState.chatHistory
       .filter((m) => m.role === 'learner')
       .pop();
@@ -341,6 +498,13 @@ export function AppProvider({ children }: AppProviderProps) {
       };
 
       if (teacherAlreadyAdded && !userAlreadyAdded) {
+        // Auto-rename conversation on first user message (if still has default name)
+        if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
+          const newTitle = pendingTranscription.length > 10 ? pendingTranscription.slice(0, 10) + '...' : pendingTranscription;
+          storage.renameConversation(conversationId, newTitle, currentState.currentLanguage);
+          dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+        }
+
         storage.addMessage('user', pendingTranscription);
         dispatch({
           type: 'ADD_MESSAGE',
@@ -361,6 +525,13 @@ export function AppProvider({ children }: AppProviderProps) {
 
       // Add user message only if not already added
       if (!userAlreadyAdded) {
+        // Auto-rename conversation on first user message (if still has default name)
+        if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
+          const newTitle = pendingTranscription.length > 10 ? pendingTranscription.slice(0, 10) + '...' : pendingTranscription;
+          storage.renameConversation(conversationId, newTitle, currentState.currentLanguage);
+          dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+        }
+
         storage.addMessage('user', pendingTranscription);
         dispatch({
           type: 'ADD_MESSAGE',
@@ -389,6 +560,26 @@ export function AppProvider({ children }: AppProviderProps) {
   // Keep refs updated
   checkAndUpdateConversationRef.current = checkAndUpdateConversation;
 
+  // Process any pending flashcards that were queued before conversation existed
+  const processPendingFlashcards = useCallback((conversationId: string) => {
+    const storage = storageRef.current;
+    const pending = pendingFlashcardsRef.current;
+
+    if (pending.length > 0) {
+      console.log(`[AppContext] Processing ${pending.length} pending flashcards for conversation ${conversationId}`);
+      const updatedFlashcards = storage.addFlashcardsForConversation(
+        conversationId,
+        pending,
+        stateRef.current.currentLanguage
+      );
+      dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+      pendingFlashcardsRef.current = [];
+    }
+  }, []);
+
+  // Keep ref updated
+  processPendingFlashcardsRef.current = processPendingFlashcards;
+
   // Handle interrupt
   const handleInterrupt = useCallback(() => {
     console.log('[AppContext] Handling interrupt');
@@ -610,11 +801,20 @@ export function AppProvider({ children }: AppProviderProps) {
 
     wsClient.on('flashcards_generated', (flashcards) => {
       const cards = flashcards as Flashcard[];
-      const updatedFlashcards = storage.addFlashcards(
-        cards,
-        stateRef.current.currentLanguage
-      );
-      dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+      const currentConvoId = stateRef.current.currentConversationId;
+      if (currentConvoId) {
+        // Conversation exists - store flashcards immediately
+        const updatedFlashcards = storage.addFlashcardsForConversation(
+          currentConvoId,
+          cards,
+          stateRef.current.currentLanguage
+        );
+        dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+      } else {
+        // No conversation yet - queue flashcards for later processing
+        console.log(`[AppContext] Queuing ${cards.length} flashcards (no conversation yet)`);
+        pendingFlashcardsRef.current = [...pendingFlashcardsRef.current, ...cards];
+      }
     });
 
     wsClient.on('feedback_generated', (data) => {
@@ -700,65 +900,20 @@ export function AppProvider({ children }: AppProviderProps) {
     }
   }, [state.isRecording]);
 
-  // Restart conversation
-  const restartConversation = useCallback(() => {
-    const audioHandler = audioHandlerRef.current;
-    const audioPlayer = audioPlayerRef.current;
-    const storage = storageRef.current;
-    const wsClient = wsClientRef.current;
-
-    if (state.isRecording) {
-      audioHandler.stopStreaming();
-      dispatch({ type: 'SET_RECORDING', payload: false });
-    }
-
-    audioPlayer.stop();
-    storage.clearConversation();
-
-    dispatch({ type: 'RESET_CONVERSATION' });
-    pendingLLMResponseRef.current = null;
-    lastPendingTranscriptionRef.current = null;
-    lastProcessedPairRef.current = null;
-
-    storage.saveState({ chatHistory: [] });
-
-    if (state.connectionStatus === 'connected') {
-      wsClient.send({ type: 'restart_conversation' });
-    }
-  }, [state.isRecording, state.connectionStatus]);
-
-  // Change language
+  // Change language (only changes the current language for new conversations)
   const changeLanguage = useCallback(
     (newLanguage: string) => {
-      const audioHandler = audioHandlerRef.current;
-      const audioPlayer = audioPlayerRef.current;
       const storage = storageRef.current;
       const wsClient = wsClientRef.current;
 
-      if (state.isRecording) {
-        audioHandler.stopStreaming();
-        dispatch({ type: 'SET_RECORDING', payload: false });
-      }
-
-      audioPlayer.stop();
-
       dispatch({ type: 'SET_LANGUAGE', payload: newLanguage });
       storage.saveLanguage(newLanguage);
 
-      storage.clearConversation();
-      dispatch({ type: 'RESET_CONVERSATION' });
-      pendingLLMResponseRef.current = null;
-      lastPendingTranscriptionRef.current = null;
-      lastProcessedPairRef.current = null;
-
-      const flashcards = storage.getFlashcards(newLanguage);
-      dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
-
       if (state.connectionStatus === 'connected') {
         wsClient.send({ type: 'set_language', languageCode: newLanguage });
       }
     },
-    [state.isRecording, state.connectionStatus]
+    [state.connectionStatus]
   );
 
   // Send text message (bypasses audio/STT)
@@ -770,6 +925,32 @@ export function AppProvider({ children }: AppProviderProps) {
 
       if (!trimmedText || state.connectionStatus !== 'connected') return;
 
+      let conversationId = stateRef.current.currentConversationId;
+      let conversationTitle: string | null = null;
+
+      // Auto-create conversation if none exists
+      if (!conversationId) {
+        const newConversation = storage.createConversation(stateRef.current.currentLanguage);
+        conversationId = newConversation.id;
+        conversationTitle = newConversation.title;
+        dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
+        dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
+        storage.setCurrentConversationId(stateRef.current.currentLanguage, newConversation.id);
+        // Process any flashcards that arrived before conversation was created
+        processPendingFlashcardsRef.current(newConversation.id);
+      } else {
+        // Get title from existing conversation in state
+        const currentConvo = stateRef.current.conversations.find((c) => c.id === conversationId);
+        conversationTitle = currentConvo?.title || null;
+      }
+
+      // Auto-rename conversation on first user message (if still has default name)
+      if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
+        const newTitle = trimmedText.length > 10 ? trimmedText.slice(0, 10) + '...' : trimmedText;
+        storage.renameConversation(conversationId, newTitle, stateRef.current.currentLanguage);
+        dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+      }
+
       // Add user message to chat history immediately (unlike audio where we wait for transcription)
       storage.addMessage('user', trimmedText);
       dispatch({
@@ -787,6 +968,185 @@ export function AppProvider({ children }: AppProviderProps) {
     [state.connectionStatus]
   );
 
+  // Select a conversation from the sidebar
+  const selectConversation = useCallback(
+    (conversationId: string) => {
+      const storage = storageRef.current;
+      const audioHandler = audioHandlerRef.current;
+      const audioPlayer = audioPlayerRef.current;
+      const wsClient = wsClientRef.current;
+
+      // Stop any ongoing recording/playback
+      if (state.isRecording) {
+        audioHandler.stopStreaming();
+        dispatch({ type: 'SET_RECORDING', payload: false });
+      }
+      audioPlayer.stop();
+
+      // Save current conversation first if it exists
+      if (state.currentConversationId && stateRef.current.chatHistory.length > 0) {
+        const messages = stateRef.current.chatHistory.map((m) => ({
+          role: m.role === 'learner' ? 'user' : 'assistant',
+          content: m.content,
+          timestamp: new Date().toISOString(),
+        })) as import('../types').ConversationMessage[];
+        storage.saveConversation(state.currentConversationId, messages, state.currentLanguage);
+      }
+
+      // Find the conversation to get its language
+      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
+      const targetLanguage = conversation?.languageCode || state.currentLanguage;
+
+      // Switch language if different
+      if (targetLanguage !== state.currentLanguage) {
+        dispatch({ type: 'SET_LANGUAGE', payload: targetLanguage });
+        storage.saveLanguage(targetLanguage);
+        if (state.connectionStatus === 'connected') {
+          wsClient.send({ type: 'set_language', languageCode: targetLanguage });
+        }
+      }
+
+      // Load the selected conversation
+      const conversationData = storage.getConversation(conversationId);
+      if (conversationData) {
+        const chatHistory = conversationData.messages.map((m) => ({
+          role: m.role === 'user' ? 'learner' : 'teacher',
+          content: m.content,
+        })) as ChatMessage[];
+        dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+      } else {
+        dispatch({ type: 'SET_CHAT_HISTORY', payload: [] });
+      }
+
+      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: conversationId });
+      storage.setCurrentConversationId(targetLanguage, conversationId);
+
+      // Load flashcards for this specific conversation
+      const flashcards = storage.getFlashcardsForConversation(conversationId);
+      dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+
+      // Reset streaming state and clear pending flashcards (they belong to old conversation)
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+      pendingLLMResponseRef.current = null;
+      lastPendingTranscriptionRef.current = null;
+      lastProcessedPairRef.current = null;
+      pendingFlashcardsRef.current = [];
+
+      // Update the WebSocket with the loaded conversation
+      if (state.connectionStatus === 'connected') {
+        wsClient.send({ type: 'conversation_context_reset' });
+        if (conversationData && conversationData.messages.length > 0) {
+          wsClient.send({
+            type: 'conversation_update',
+            data: { messages: conversationData.messages },
+          });
+        }
+      }
+
+      // Close sidebar on mobile
+      dispatch({ type: 'SET_SIDEBAR_OPEN', payload: false });
+    },
+    [state.isRecording, state.currentConversationId, state.currentLanguage, state.connectionStatus]
+  );
+
+  // Create a new conversation
+  const createNewConversation = useCallback(() => {
+    const storage = storageRef.current;
+    const audioHandler = audioHandlerRef.current;
+    const audioPlayer = audioPlayerRef.current;
+    const wsClient = wsClientRef.current;
+
+    // Stop any ongoing recording/playback
+    if (state.isRecording) {
+      audioHandler.stopStreaming();
+      dispatch({ type: 'SET_RECORDING', payload: false });
+    }
+    audioPlayer.stop();
+
+    // Save current conversation first if it exists
+    if (state.currentConversationId && stateRef.current.chatHistory.length > 0) {
+      const messages = stateRef.current.chatHistory.map((m) => ({
+        role: m.role === 'learner' ? 'user' : 'assistant',
+        content: m.content,
+        timestamp: new Date().toISOString(),
+      })) as import('../types').ConversationMessage[];
+      storage.saveConversation(state.currentConversationId, messages, state.currentLanguage);
+    }
+
+    // Create new conversation
+    const newConversation = storage.createConversation(state.currentLanguage);
+    dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
+    dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
+    storage.setCurrentConversationId(state.currentLanguage, newConversation.id);
+
+    // Clear chat and flashcards (new conversation has no flashcards)
+    dispatch({ type: 'RESET_CONVERSATION' });
+    dispatch({ type: 'SET_FLASHCARDS', payload: [] });
+    pendingLLMResponseRef.current = null;
+    lastPendingTranscriptionRef.current = null;
+    lastProcessedPairRef.current = null;
+    pendingFlashcardsRef.current = [];
+
+    // Reset WebSocket conversation
+    if (state.connectionStatus === 'connected') {
+      wsClient.send({ type: 'conversation_context_reset' });
+    }
+
+    // Close sidebar on mobile
+    dispatch({ type: 'SET_SIDEBAR_OPEN', payload: false });
+  }, [state.isRecording, state.currentConversationId, state.currentLanguage, state.connectionStatus]);
+
+  // Delete a conversation
+  const deleteConversation = useCallback(
+    (conversationId: string) => {
+      const storage = storageRef.current;
+
+      // Find the conversation to get its language code
+      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
+      const languageCode = conversation?.languageCode || state.currentLanguage;
+
+      storage.deleteConversation(conversationId, languageCode);
+      storage.clearFlashcardsForConversation(conversationId);
+      dispatch({ type: 'REMOVE_CONVERSATION', payload: conversationId });
+
+      // If we deleted the current conversation, switch to another or create new
+      if (state.currentConversationId === conversationId) {
+        const remainingConversations = stateRef.current.conversations.filter(
+          (c) => c.id !== conversationId
+        );
+
+        if (remainingConversations.length > 0) {
+          selectConversation(remainingConversations[0].id);
+        } else {
+          createNewConversation();
+        }
+      }
+    },
+    [state.currentLanguage, state.currentConversationId, selectConversation, createNewConversation]
+  );
+
+  // Rename a conversation
+  const renameConversation = useCallback(
+    (conversationId: string, newTitle: string) => {
+      const storage = storageRef.current;
+      const trimmedTitle = newTitle.trim();
+      if (!trimmedTitle) return;
+
+      // Find the conversation to get its language code
+      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
+      const languageCode = conversation?.languageCode || state.currentLanguage;
+
+      storage.renameConversation(conversationId, trimmedTitle, languageCode);
+      dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: trimmedTitle } });
+    },
+    [state.currentLanguage]
+  );
+
+  // Toggle sidebar
+  const toggleSidebar = useCallback(() => {
+    dispatch({ type: 'SET_SIDEBAR_OPEN', payload: !stateRef.current.sidebarOpen });
+  }, []);
+
   const value: AppContextType = {
     state,
     dispatch,
@@ -795,10 +1155,14 @@ export function AppProvider({ children }: AppProviderProps) {
     audioHandler: audioHandlerRef.current,
     audioPlayer: audioPlayerRef.current,
     toggleRecording,
-    restartConversation,
     changeLanguage,
     handleInterrupt,
     sendTextMessage,
+    selectConversation,
+    createNewConversation,
+    deleteConversation,
+    renameConversation,
+    toggleSidebar,
   };
 
   return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
diff --git a/frontend/src/context/AuthContext.tsx b/frontend/src/context/AuthContext.tsx
new file mode 100644
index 0000000..ff59cb9
--- /dev/null
+++ b/frontend/src/context/AuthContext.tsx
@@ -0,0 +1,118 @@
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  type ReactNode,
+} from 'react';
+import { createClient } from '@supabase/supabase-js';
+import type { SupabaseClient, User, Session } from '@supabase/supabase-js';
+
+interface AuthContextType {
+  supabase: SupabaseClient | null;
+  user: User | null;
+  session: Session | null;
+  isLoading: boolean;
+  isConfigured: boolean;
+  signUp: (email: string, password: string) => Promise<{ error: string | null }>;
+  signIn: (email: string, password: string) => Promise<{ error: string | null }>;
+  signOut: () => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextType | null>(null);
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [supabase] = useState<SupabaseClient | null>(() => {
+    const url = import.meta.env.VITE_SUPABASE_URL;
+    const publishableKey = import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY;
+
+    if (!url || !publishableKey) {
+      console.log('Supabase not configured - running in anonymous mode');
+      return null;
+    }
+
+    return createClient(url, publishableKey);
+  });
+
+  const [user, setUser] = useState<User | null>(null);
+  const [session, setSession] = useState<Session | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const isConfigured = supabase !== null;
+
+  useEffect(() => {
+    if (!supabase) {
+      setIsLoading(false);
+      return;
+    }
+
+    // Get initial session
+    supabase.auth.getSession().then(({ data: { session } }) => {
+      setSession(session);
+      setUser(session?.user ?? null);
+      setIsLoading(false);
+    });
+
+    // Listen for auth changes
+    const {
+      data: { subscription },
+    } = supabase.auth.onAuthStateChange((_event, session) => {
+      setSession(session);
+      setUser(session?.user ?? null);
+    });
+
+    return () => subscription.unsubscribe();
+  }, [supabase]);
+
+  const signUp = async (email: string, password: string): Promise<{ error: string | null }> => {
+    if (!supabase) return { error: 'Supabase not configured' };
+
+    const { error } = await supabase.auth.signUp({
+      email,
+      password,
+    });
+
+    return { error: error?.message ?? null };
+  };
+
+  const signIn = async (email: string, password: string): Promise<{ error: string | null }> => {
+    if (!supabase) return { error: 'Supabase not configured' };
+
+    const { error } = await supabase.auth.signInWithPassword({
+      email,
+      password,
+    });
+
+    return { error: error?.message ?? null };
+  };
+
+  const signOut = async () => {
+    if (!supabase) return;
+    await supabase.auth.signOut();
+  };
+
+  return (
+    <AuthContext.Provider
+      value={{
+        supabase,
+        user,
+        session,
+        isLoading,
+        isConfigured,
+        signUp,
+        signIn,
+        signOut,
+      }}
+    >
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within AuthProvider');
+  }
+  return context;
+}
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index 3a8bd35..26af896 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -1,9 +1,12 @@
 import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
+import { AuthProvider } from './context/AuthContext';
 import App from './App.tsx';
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <App />
+    <AuthProvider>
+      <App />
+    </AuthProvider>
   </StrictMode>
 );
diff --git a/frontend/src/services/HybridStorage.ts b/frontend/src/services/HybridStorage.ts
new file mode 100644
index 0000000..8d66328
--- /dev/null
+++ b/frontend/src/services/HybridStorage.ts
@@ -0,0 +1,236 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import { Storage } from './Storage';
+import { SupabaseStorage } from './SupabaseStorage';
+import type {
+  Flashcard,
+  ConversationSummary,
+  ConversationMessage,
+} from '../types';
+
+export class HybridStorage extends Storage {
+  private supabaseStorage: SupabaseStorage | null = null;
+  private syncInProgress = false;
+
+  setSupabaseClient(supabase: SupabaseClient, userId: string): void {
+    this.supabaseStorage = new SupabaseStorage(supabase, userId);
+  }
+
+  clearSupabaseClient(): void {
+    this.supabaseStorage = null;
+  }
+
+  isSupabaseConnected(): boolean {
+    return this.supabaseStorage !== null;
+  }
+
+  // Override methods to sync with Supabase
+
+  override saveLanguage(languageCode: string): void {
+    super.saveLanguage(languageCode);
+    this.supabaseStorage?.saveLanguage(languageCode).catch(console.error);
+  }
+
+  override saveConversation(
+    conversationId: string,
+    messages: ConversationMessage[],
+    languageCode: string
+  ): void {
+    super.saveConversation(conversationId, messages, languageCode);
+    this.supabaseStorage
+      ?.saveConversation(conversationId, messages, languageCode)
+      .catch(console.error);
+  }
+
+  override createConversation(languageCode: string): ConversationSummary {
+    const summary = super.createConversation(languageCode);
+    // Sync to Supabase using the same ID as localStorage
+    this.supabaseStorage
+      ?.createConversation(languageCode, summary.title, summary.id)
+      .catch(console.error);
+    return summary;
+  }
+
+  override deleteConversation(conversationId: string, languageCode: string): void {
+    super.deleteConversation(conversationId, languageCode);
+    this.supabaseStorage?.deleteConversation(conversationId).catch(console.error);
+  }
+
+  override renameConversation(conversationId: string, newTitle: string, languageCode: string): void {
+    super.renameConversation(conversationId, newTitle, languageCode);
+    this.supabaseStorage?.renameConversation(conversationId, newTitle).catch(console.error);
+  }
+
+  override addFlashcards(newFlashcards: Flashcard[], languageCode: string): Flashcard[] {
+    const result = super.addFlashcards(newFlashcards, languageCode);
+    this.supabaseStorage
+      ?.addFlashcards(newFlashcards, languageCode)
+      .catch(console.error);
+    return result;
+  }
+
+  override clearFlashcards(languageCode: string): void {
+    super.clearFlashcards(languageCode);
+    this.supabaseStorage?.clearFlashcards(languageCode).catch(console.error);
+  }
+
+  // Per-conversation flashcard methods
+  override addFlashcardsForConversation(
+    conversationId: string,
+    newFlashcards: Flashcard[],
+    languageCode: string
+  ): Flashcard[] {
+    const result = super.addFlashcardsForConversation(conversationId, newFlashcards, languageCode);
+    this.supabaseStorage
+      ?.addFlashcardsForConversation(conversationId, newFlashcards, languageCode)
+      .catch(console.error);
+    return result;
+  }
+
+  override clearFlashcardsForConversation(conversationId: string): void {
+    super.clearFlashcardsForConversation(conversationId);
+    this.supabaseStorage?.clearFlashcardsForConversation(conversationId).catch(console.error);
+  }
+
+  // Migration: upload localStorage data to Supabase
+  async migrateToSupabase(languages: string[]): Promise<void> {
+    if (!this.supabaseStorage || this.syncInProgress) return;
+
+    this.syncInProgress = true;
+    try {
+      // Migrate language preference
+      const language = this.getLanguage();
+      await this.supabaseStorage.saveLanguage(language);
+
+      // Migrate conversations and flashcards for each language
+      for (const lang of languages) {
+        // Migrate conversations
+        const conversations = super.getConversationList(lang);
+        for (const conv of conversations) {
+          try {
+            // Create conversation in Supabase using the SAME ID as localStorage
+            await this.supabaseStorage.createConversation(
+              lang,
+              conv.title,
+              conv.id // Pass the local ID to use in Supabase
+            );
+
+            // Get messages and save to Supabase
+            const data = super.getConversation(conv.id);
+            if (data && data.messages.length > 0) {
+              await this.supabaseStorage.saveConversation(
+                conv.id,
+                data.messages,
+                lang
+              );
+            }
+          } catch (e) {
+            // Conversation might already exist, that's OK
+            console.log(`Conversation ${conv.id} may already exist:`, e);
+          }
+        }
+
+        // Migrate flashcards
+        const flashcards = super.getFlashcards(lang);
+        if (flashcards.length > 0) {
+          await this.supabaseStorage.addFlashcards(flashcards, lang);
+        }
+      }
+
+      console.log('Migration to Supabase complete');
+    } finally {
+      this.syncInProgress = false;
+    }
+  }
+
+  // Sync: merge Supabase data with localStorage (on login)
+  // This preserves any anonymous conversations while also loading cloud data
+  async syncFromSupabase(languages: string[]): Promise<{
+    conversations: Map<string, ConversationSummary[]>;
+    flashcards: Map<string, Flashcard[]>;
+  }> {
+    if (!this.supabaseStorage) {
+      return { conversations: new Map(), flashcards: new Map() };
+    }
+
+    const conversations = new Map<string, ConversationSummary[]>();
+    const flashcards = new Map<string, Flashcard[]>();
+
+    try {
+      // Sync conversations and flashcards for each language
+      for (const lang of languages) {
+        // Get both remote and local conversations
+        const remoteConversations =
+          await this.supabaseStorage.getConversationList(lang);
+        const localConversations = super.getConversationList(lang);
+
+        // Merge: remote conversations + local conversations not in remote
+        const remoteIds = new Set(remoteConversations.map((c) => c.id));
+        const localOnly = localConversations.filter((c) => !remoteIds.has(c.id));
+        const merged = [...remoteConversations, ...localOnly];
+
+        // Sort by updatedAt descending
+        merged.sort(
+          (a, b) =>
+            new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+        );
+
+        conversations.set(lang, merged);
+
+        // Save merged list to localStorage
+        try {
+          localStorage.setItem(
+            `aprende-conversations-${lang}`,
+            JSON.stringify(merged)
+          );
+
+          // Load remote conversation messages to localStorage
+          for (const conv of remoteConversations) {
+            const data = await this.supabaseStorage.getConversation(conv.id);
+            if (data) {
+              localStorage.setItem(
+                `aprende-conversation-${conv.id}`,
+                JSON.stringify(data)
+              );
+            }
+          }
+        } catch (e) {
+          console.error('Failed to sync conversations to localStorage:', e);
+        }
+
+        // Merge flashcards: combine remote + local, deduplicate by targetWord
+        const remoteFlashcards = await this.supabaseStorage.getFlashcards(lang);
+        const localFlashcards = super.getFlashcards(lang);
+
+        const seenWords = new Set<string>();
+        const mergedFlashcards: Flashcard[] = [];
+
+        // Remote flashcards take priority
+        for (const f of remoteFlashcards) {
+          const word = (f.targetWord || '').toLowerCase();
+          if (!seenWords.has(word)) {
+            seenWords.add(word);
+            mergedFlashcards.push(f);
+          }
+        }
+        // Add local flashcards not in remote
+        for (const f of localFlashcards) {
+          const word = (f.targetWord || '').toLowerCase();
+          if (!seenWords.has(word)) {
+            seenWords.add(word);
+            mergedFlashcards.push(f);
+          }
+        }
+
+        flashcards.set(lang, mergedFlashcards);
+        super.saveFlashcards(mergedFlashcards, lang);
+      }
+
+      console.log('Sync from Supabase complete (merged with local data)');
+    } catch (e) {
+      console.error('Failed to sync from Supabase:', e);
+    }
+
+    return { conversations, flashcards };
+  }
+
+}
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index 9a846c9..875e4dc 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -1,9 +1,19 @@
-import type { Flashcard, ConversationHistory } from '../types';
+import type {
+  Flashcard,
+  ConversationHistory,
+  ConversationSummary,
+  ConversationData,
+  ConversationMessage,
+} from '../types';
 
 export class Storage {
   private storageKey = 'aprende-app-state';
-  private conversationKey = 'aprende-conversation-history';
-  private flashcardsKey = 'aprende-flashcards';
+  private conversationKey = 'aprende-conversation-history'; // Legacy single conversation
+  private conversationsListKeyPrefix = 'aprende-conversations-'; // + languageCode
+  private conversationDataKeyPrefix = 'aprende-conversation-'; // + conversationId
+  private currentConversationKeyPrefix = 'aprende-current-conversation-'; // + languageCode
+  private flashcardsKey = 'aprende-flashcards'; // Legacy per-language flashcards
+  private flashcardsConversationKeyPrefix = 'aprende-flashcards-conv-'; // + conversationId
   private languageKey = 'aprende-language';
   private userIdKey = 'aprende-user-id';
 
@@ -122,6 +132,239 @@ export class Storage {
     }
   }
 
+  // Multi-conversation methods
+
+  private generateId(): string {
+    return typeof crypto !== 'undefined' && crypto.randomUUID
+      ? crypto.randomUUID()
+      : `c_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+  }
+
+  getConversationList(languageCode: string): ConversationSummary[] {
+    try {
+      const key = this.conversationsListKeyPrefix + languageCode;
+      const data = localStorage.getItem(key);
+      if (!data) {
+        // Check for legacy data to migrate
+        return this.migrateToMultiConversation(languageCode);
+      }
+      return JSON.parse(data);
+    } catch (error) {
+      console.error('Failed to load conversation list:', error);
+      return [];
+    }
+  }
+
+  private migrateToMultiConversation(languageCode: string): ConversationSummary[] {
+    // Check if there's legacy conversation data
+    const legacyData = localStorage.getItem(this.conversationKey);
+    const currentLanguage = this.getLanguage();
+
+    // Only migrate if we have legacy data AND we're loading for the same language
+    if (legacyData && currentLanguage === languageCode) {
+      try {
+        const legacy = JSON.parse(legacyData) as ConversationHistory;
+        if (legacy.messages && legacy.messages.length > 0) {
+          // Create first conversation from legacy data
+          const conversationId = this.generateId();
+          const now = new Date().toISOString();
+          const randomNumbers = Math.floor(10000 + Math.random() * 90000);
+          const summary: ConversationSummary = {
+            id: conversationId,
+            title: `Chat ${randomNumbers}`,
+            languageCode,
+            createdAt: now,
+            updatedAt: now,
+          };
+
+          const conversationData: ConversationData = {
+            id: conversationId,
+            messages: legacy.messages,
+          };
+
+          // Save the migrated data
+          localStorage.setItem(
+            this.conversationsListKeyPrefix + languageCode,
+            JSON.stringify([summary])
+          );
+          localStorage.setItem(
+            this.conversationDataKeyPrefix + conversationId,
+            JSON.stringify(conversationData)
+          );
+          localStorage.setItem(
+            this.currentConversationKeyPrefix + languageCode,
+            conversationId
+          );
+
+          // Remove legacy data
+          localStorage.removeItem(this.conversationKey);
+
+          return [summary];
+        }
+      } catch (error) {
+        console.error('Failed to migrate legacy conversation:', error);
+      }
+    }
+    return [];
+  }
+
+  getConversation(conversationId: string): ConversationData | null {
+    try {
+      const key = this.conversationDataKeyPrefix + conversationId;
+      const data = localStorage.getItem(key);
+      if (!data) return null;
+      return JSON.parse(data);
+    } catch (error) {
+      console.error('Failed to load conversation:', error);
+      return null;
+    }
+  }
+
+  saveConversation(conversationId: string, messages: ConversationMessage[], languageCode: string): void {
+    try {
+      const conversationData: ConversationData = {
+        id: conversationId,
+        messages,
+      };
+      localStorage.setItem(
+        this.conversationDataKeyPrefix + conversationId,
+        JSON.stringify(conversationData)
+      );
+
+      // Update the summary's updatedAt timestamp
+      const list = this.getConversationList(languageCode);
+      const index = list.findIndex((c) => c.id === conversationId);
+      if (index !== -1) {
+        list[index].updatedAt = new Date().toISOString();
+        localStorage.setItem(
+          this.conversationsListKeyPrefix + languageCode,
+          JSON.stringify(list)
+        );
+      }
+    } catch (error) {
+      console.error('Failed to save conversation:', error);
+    }
+  }
+
+  createConversation(languageCode: string): ConversationSummary {
+    const list = this.getConversationList(languageCode);
+    const now = new Date().toISOString();
+    const conversationId = this.generateId();
+    const randomNumbers = Math.floor(10000 + Math.random() * 90000);
+
+    const summary: ConversationSummary = {
+      id: conversationId,
+      title: `Chat ${randomNumbers}`,
+      languageCode,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    // Add to beginning of list (most recent first)
+    list.unshift(summary);
+
+    localStorage.setItem(
+      this.conversationsListKeyPrefix + languageCode,
+      JSON.stringify(list)
+    );
+
+    // Create empty conversation data
+    const conversationData: ConversationData = {
+      id: conversationId,
+      messages: [],
+    };
+    localStorage.setItem(
+      this.conversationDataKeyPrefix + conversationId,
+      JSON.stringify(conversationData)
+    );
+
+    return summary;
+  }
+
+  deleteConversation(conversationId: string, languageCode: string): void {
+    try {
+      // Remove conversation data
+      localStorage.removeItem(this.conversationDataKeyPrefix + conversationId);
+
+      // Remove from list
+      const list = this.getConversationList(languageCode);
+      const filtered = list.filter((c) => c.id !== conversationId);
+      localStorage.setItem(
+        this.conversationsListKeyPrefix + languageCode,
+        JSON.stringify(filtered)
+      );
+
+      // If this was the current conversation, clear current
+      const currentId = this.getCurrentConversationId(languageCode);
+      if (currentId === conversationId) {
+        localStorage.removeItem(this.currentConversationKeyPrefix + languageCode);
+      }
+    } catch (error) {
+      console.error('Failed to delete conversation:', error);
+    }
+  }
+
+  renameConversation(conversationId: string, newTitle: string, languageCode: string): void {
+    try {
+      const list = this.getConversationList(languageCode);
+      const index = list.findIndex((c) => c.id === conversationId);
+      if (index !== -1) {
+        list[index].title = newTitle;
+        list[index].updatedAt = new Date().toISOString();
+        localStorage.setItem(
+          this.conversationsListKeyPrefix + languageCode,
+          JSON.stringify(list)
+        );
+      }
+    } catch (error) {
+      console.error('Failed to rename conversation:', error);
+    }
+  }
+
+  getCurrentConversationId(languageCode: string): string | null {
+    try {
+      return localStorage.getItem(this.currentConversationKeyPrefix + languageCode);
+    } catch {
+      return null;
+    }
+  }
+
+  setCurrentConversationId(languageCode: string, conversationId: string): void {
+    try {
+      localStorage.setItem(
+        this.currentConversationKeyPrefix + languageCode,
+        conversationId
+      );
+    } catch (error) {
+      console.error('Failed to set current conversation:', error);
+    }
+  }
+
+  getAllConversations(): ConversationSummary[] {
+    try {
+      const allConversations: ConversationSummary[] = [];
+      // Iterate through all localStorage keys to find conversation lists
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(this.conversationsListKeyPrefix)) {
+          const data = localStorage.getItem(key);
+          if (data) {
+            const conversations = JSON.parse(data) as ConversationSummary[];
+            allConversations.push(...conversations);
+          }
+        }
+      }
+      // Sort by updatedAt descending (most recent first)
+      allConversations.sort((a, b) =>
+        new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+      return allConversations;
+    } catch (error) {
+      console.error('Failed to get all conversations:', error);
+      return [];
+    }
+  }
+
   // Flashcard methods
   private getFlashcardsKey(languageCode?: string): string {
     if (!languageCode) {
@@ -209,4 +452,70 @@ export class Storage {
       console.error('Failed to clear flashcards from localStorage:', error);
     }
   }
+
+  // Per-conversation flashcard methods
+  getFlashcardsForConversation(conversationId: string): Flashcard[] {
+    try {
+      const key = this.flashcardsConversationKeyPrefix + conversationId;
+      const data = localStorage.getItem(key);
+      if (!data) return [];
+      return JSON.parse(data);
+    } catch (error) {
+      console.error('Failed to load flashcards for conversation:', error);
+      return [];
+    }
+  }
+
+  saveFlashcardsForConversation(conversationId: string, flashcards: Flashcard[]): void {
+    try {
+      const key = this.flashcardsConversationKeyPrefix + conversationId;
+      localStorage.setItem(key, JSON.stringify(flashcards));
+    } catch (error) {
+      console.error('Failed to save flashcards for conversation:', error);
+    }
+  }
+
+  addFlashcardsForConversation(
+    conversationId: string,
+    newFlashcards: Flashcard[],
+    languageCode: string
+  ): Flashcard[] {
+    const existingFlashcards = this.getFlashcardsForConversation(conversationId);
+
+    // Filter out duplicates
+    const uniqueNewFlashcards = newFlashcards.filter((newCard) => {
+      const newWord = newCard.targetWord || newCard.spanish || '';
+      return !existingFlashcards.some((existing) => {
+        const existingWord = existing.targetWord || existing.spanish || '';
+        return existingWord.toLowerCase() === newWord.toLowerCase();
+      });
+    });
+
+    // Add conversation ID and language code to new flashcards
+    const flashcardsWithIds = uniqueNewFlashcards.map((card) => ({
+      ...card,
+      targetWord: card.targetWord || card.spanish || '',
+      conversationId,
+      languageCode,
+    }));
+
+    const updatedFlashcards = [...existingFlashcards, ...flashcardsWithIds];
+
+    // Keep only the last 100 flashcards per conversation
+    if (updatedFlashcards.length > 100) {
+      updatedFlashcards.splice(0, updatedFlashcards.length - 100);
+    }
+
+    this.saveFlashcardsForConversation(conversationId, updatedFlashcards);
+    return updatedFlashcards;
+  }
+
+  clearFlashcardsForConversation(conversationId: string): void {
+    try {
+      const key = this.flashcardsConversationKeyPrefix + conversationId;
+      localStorage.removeItem(key);
+    } catch (error) {
+      console.error('Failed to clear flashcards for conversation:', error);
+    }
+  }
 }
diff --git a/frontend/src/services/SupabaseStorage.ts b/frontend/src/services/SupabaseStorage.ts
new file mode 100644
index 0000000..71e0a73
--- /dev/null
+++ b/frontend/src/services/SupabaseStorage.ts
@@ -0,0 +1,272 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type {
+  Flashcard,
+  ConversationSummary,
+  ConversationData,
+  ConversationMessage,
+} from '../types';
+
+export class SupabaseStorage {
+  private supabase: SupabaseClient;
+  private userId: string;
+
+  constructor(supabase: SupabaseClient, userId: string) {
+    this.supabase = supabase;
+    this.userId = userId;
+  }
+
+  // User preferences
+
+  async getLanguage(): Promise<string> {
+    const { data } = await this.supabase
+      .from('user_preferences')
+      .select('language_code')
+      .eq('user_id', this.userId)
+      .maybeSingle();
+    return data?.language_code ?? 'es';
+  }
+
+  async saveLanguage(languageCode: string): Promise<void> {
+    await this.supabase.from('user_preferences').upsert(
+      {
+        user_id: this.userId,
+        language_code: languageCode,
+        updated_at: new Date().toISOString(),
+      },
+      { onConflict: 'user_id' }
+    );
+  }
+
+  // Conversations
+
+  async getConversationList(languageCode: string): Promise<ConversationSummary[]> {
+    const { data } = await this.supabase
+      .from('conversations')
+      .select('id, title, language_code, created_at, updated_at')
+      .eq('user_id', this.userId)
+      .eq('language_code', languageCode)
+      .order('updated_at', { ascending: false });
+
+    return (data ?? []).map((c) => ({
+      id: c.id,
+      title: c.title,
+      languageCode: c.language_code,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at,
+    }));
+  }
+
+  async getConversation(conversationId: string): Promise<ConversationData | null> {
+    const { data: messages } = await this.supabase
+      .from('conversation_messages')
+      .select('role, content, created_at')
+      .eq('conversation_id', conversationId)
+      .order('created_at', { ascending: true });
+
+    if (!messages) return null;
+
+    return {
+      id: conversationId,
+      messages: messages.map((m) => ({
+        role: m.role as 'user' | 'assistant',
+        content: m.content,
+        timestamp: m.created_at,
+      })),
+    };
+  }
+
+  async saveConversation(
+    conversationId: string,
+    messages: ConversationMessage[],
+    _languageCode: string
+  ): Promise<void> {
+    // Delete existing messages for this conversation
+    await this.supabase
+      .from('conversation_messages')
+      .delete()
+      .eq('conversation_id', conversationId);
+
+    // Insert new messages
+    if (messages.length > 0) {
+      await this.supabase.from('conversation_messages').insert(
+        messages.map((m) => ({
+          conversation_id: conversationId,
+          role: m.role,
+          content: m.content,
+          created_at: m.timestamp || new Date().toISOString(),
+        }))
+      );
+    }
+
+    // Update conversation's updated_at
+    await this.supabase
+      .from('conversations')
+      .update({ updated_at: new Date().toISOString() })
+      .eq('id', conversationId);
+  }
+
+  async createConversation(
+    languageCode: string,
+    title: string,
+    id?: string
+  ): Promise<ConversationSummary> {
+    const now = new Date().toISOString();
+    const insertData: Record<string, unknown> = {
+      user_id: this.userId,
+      language_code: languageCode,
+      title,
+      created_at: now,
+      updated_at: now,
+    };
+
+    // Use provided ID if given (to match localStorage ID)
+    if (id) {
+      insertData.id = id;
+
+      // Check if conversation already exists
+      const { data: existing } = await this.supabase
+        .from('conversations')
+        .select('id, title, language_code, created_at, updated_at')
+        .eq('id', id)
+        .maybeSingle();
+
+      if (existing) {
+        return {
+          id: existing.id,
+          title: existing.title,
+          languageCode: existing.language_code,
+          createdAt: existing.created_at,
+          updatedAt: existing.updated_at,
+        };
+      }
+    }
+
+    const { data, error } = await this.supabase
+      .from('conversations')
+      .insert(insertData)
+      .select('id, title, language_code, created_at, updated_at')
+      .single();
+
+    if (error || !data) {
+      throw new Error(`Failed to create conversation: ${error?.message}`);
+    }
+
+    return {
+      id: data.id,
+      title: data.title,
+      languageCode: data.language_code,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at,
+    };
+  }
+
+  async deleteConversation(conversationId: string): Promise<void> {
+    // Messages will be cascade deleted
+    await this.supabase.from('conversations').delete().eq('id', conversationId);
+  }
+
+  async renameConversation(conversationId: string, newTitle: string): Promise<void> {
+    await this.supabase
+      .from('conversations')
+      .update({ title: newTitle, updated_at: new Date().toISOString() })
+      .eq('id', conversationId);
+  }
+
+  // Flashcards
+
+  async getFlashcards(languageCode: string): Promise<Flashcard[]> {
+    const { data } = await this.supabase
+      .from('flashcards')
+      .select('*')
+      .eq('user_id', this.userId)
+      .eq('language_code', languageCode)
+      .order('created_at', { ascending: false })
+      .limit(100);
+
+    return (data ?? []).map((f) => ({
+      targetWord: f.target_word,
+      english: f.english,
+      example: f.example,
+      mnemonic: f.mnemonic,
+      timestamp: f.created_at,
+      languageCode: f.language_code,
+    }));
+  }
+
+  async addFlashcards(
+    flashcards: Flashcard[],
+    languageCode: string
+  ): Promise<void> {
+    const toInsert = flashcards.map((f) => ({
+      user_id: this.userId,
+      language_code: languageCode,
+      target_word: f.targetWord || f.spanish || '',
+      english: f.english,
+      example: f.example,
+      mnemonic: f.mnemonic,
+    }));
+
+    // Use upsert to handle duplicates gracefully
+    await this.supabase
+      .from('flashcards')
+      .upsert(toInsert, { onConflict: 'user_id,language_code,target_word' });
+  }
+
+  async clearFlashcards(languageCode: string): Promise<void> {
+    await this.supabase
+      .from('flashcards')
+      .delete()
+      .eq('user_id', this.userId)
+      .eq('language_code', languageCode);
+  }
+
+  // Per-conversation flashcard methods
+  async getFlashcardsForConversation(conversationId: string): Promise<Flashcard[]> {
+    const { data } = await this.supabase
+      .from('flashcards')
+      .select('*')
+      .eq('user_id', this.userId)
+      .eq('conversation_id', conversationId)
+      .order('created_at', { ascending: false })
+      .limit(100);
+
+    return (data ?? []).map((f) => ({
+      targetWord: f.target_word,
+      english: f.english,
+      example: f.example,
+      mnemonic: f.mnemonic,
+      timestamp: f.created_at,
+      languageCode: f.language_code,
+      conversationId: f.conversation_id,
+    }));
+  }
+
+  async addFlashcardsForConversation(
+    conversationId: string,
+    flashcards: Flashcard[],
+    languageCode: string
+  ): Promise<void> {
+    const toInsert = flashcards.map((f) => ({
+      user_id: this.userId,
+      conversation_id: conversationId,
+      language_code: languageCode,
+      target_word: f.targetWord || f.spanish || '',
+      english: f.english,
+      example: f.example,
+      mnemonic: f.mnemonic,
+    }));
+
+    // Use upsert to handle duplicates gracefully
+    await this.supabase
+      .from('flashcards')
+      .upsert(toInsert, { onConflict: 'user_id,conversation_id,target_word' });
+  }
+
+  async clearFlashcardsForConversation(conversationId: string): Promise<void> {
+    await this.supabase
+      .from('flashcards')
+      .delete()
+      .eq('user_id', this.userId)
+      .eq('conversation_id', conversationId);
+  }
+}
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index dc25cc1..9c28268 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -21,40 +21,469 @@ body {
     padding: 0 24px;
 }
 
+/* App Layout with Sidebar */
+.app-wrapper {
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+}
+
+.app-layout {
+    display: flex;
+    flex: 1;
+    min-height: 0;
+}
+
+.app-main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+/* Sidebar */
+.sidebar {
+    width: 260px;
+    background: #f9fafb;
+    border-right: 1px solid #e5e5e5;
+    display: flex;
+    flex-direction: column;
+    flex-shrink: 0;
+}
+
+/* Sidebar Brand */
+.sidebar-brand {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px;
+    min-height: 57px;
+    background: #ffffff;
+}
+
+.sidebar-logo {
+    font-size: 18px;
+    font-weight: 600;
+    color: #1a1a1a;
+    margin: 0;
+}
+
+.sidebar-header {
+    padding: 16px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.new-chat-wrapper {
+    display: flex;
+    flex: 1;
+    position: relative;
+}
+
+.new-chat-button {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex: 1;
+    padding: 10px 16px;
+    background: #1a1a1a;
+    color: #ffffff;
+    border: none;
+    border-radius: 8px 0 0 8px;
+    font-family: inherit;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.new-chat-button:hover {
+    background: #333333;
+}
+
+.new-chat-lang-button {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    padding: 10px 12px;
+    background: #1a1a1a;
+    color: #ffffff;
+    border: none;
+    border-left: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 0 8px 8px 0;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.new-chat-lang-button:hover {
+    background: #333333;
+}
+
+.new-chat-lang-button .lang-flag {
+    font-size: 18px;
+    line-height: 1;
+}
+
+.new-chat-lang-dropdown {
+    position: absolute;
+    top: calc(100% + 8px);
+    left: 0;
+    right: 0;
+    background: #ffffff;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+    z-index: 100;
+    overflow: hidden;
+}
+
+.sidebar-close-button {
+    display: none;
+    width: 36px;
+    height: 36px;
+    border: none;
+    background: transparent;
+    color: #6b7280;
+    cursor: pointer;
+    border-radius: 8px;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s ease;
+}
+
+.sidebar-close-button:hover {
+    background: #e5e5e5;
+    color: #1a1a1a;
+}
+
+.sidebar-conversations {
+    flex: 1;
+    overflow-y: auto;
+    padding: 12px;
+}
+
+.sidebar-empty {
+    padding: 24px 12px;
+    text-align: center;
+    color: #6b7280;
+}
+
+.sidebar-empty p {
+    margin: 0;
+}
+
+.sidebar-empty-hint {
+    font-size: 13px;
+    margin-top: 8px !important;
+    opacity: 0.8;
+}
+
+.conversation-list {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+.conversation-item {
+    display: flex;
+    align-items: center;
+    border-radius: 8px;
+    margin-bottom: 4px;
+    transition: background-color 0.15s ease;
+}
+
+.conversation-item:hover {
+    background: #e5e5e5;
+}
+
+.conversation-item.active {
+    background: #e5e5e5;
+}
+
+.conversation-button {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 12px;
+    background: none;
+    border: none;
+    font-family: inherit;
+    font-size: 14px;
+    color: #1a1a1a;
+    cursor: pointer;
+    text-align: left;
+    min-width: 0;
+}
+
+.conversation-flag-left {
+    font-size: 18px;
+    flex-shrink: 0;
+    line-height: 1;
+}
+
+.conversation-title {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    flex: 1;
+}
+
+.conversation-actions {
+    display: none;
+    align-items: center;
+    gap: 2px;
+    margin-right: 8px;
+}
+
+.conversation-item:hover .conversation-actions {
+    display: flex;
+}
+
+.conversation-action-btn {
+    width: 28px;
+    height: 28px;
+    border: none;
+    background: transparent;
+    color: #9ca3af;
+    cursor: pointer;
+    border-radius: 6px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.15s ease;
+}
+
+.conversation-action-btn:hover {
+    background: #d1d5db;
+    color: #1a1a1a;
+}
+
+.conversation-action-btn.conversation-delete:hover {
+    color: #ef4444;
+}
+
+.conversation-edit {
+    flex: 1;
+    padding: 4px 8px;
+}
+
+.conversation-edit-input {
+    width: 100%;
+    font-family: inherit;
+    font-size: 14px;
+    padding: 6px 10px;
+    border: 1px solid #1a1a1a;
+    border-radius: 6px;
+    background: #ffffff;
+    color: #1a1a1a;
+    outline: none;
+}
+
+/* Sidebar Overlay (mobile) */
+.sidebar-overlay {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 40;
+}
+
+/* Menu toggle button in header */
+.menu-toggle {
+    display: none;
+    width: 40px;
+    height: 40px;
+    border: none;
+    background: transparent;
+    color: #1a1a1a;
+    cursor: pointer;
+    border-radius: 8px;
+    align-items: center;
+    justify-content: center;
+    transition: background-color 0.2s ease;
+}
+
+.menu-toggle:hover {
+    background: #f3f4f6;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.header-logo {
+    font-size: 18px;
+    font-weight: 600;
+    color: #1a1a1a;
+    margin: 0;
+}
+
 /* Header */
 .header {
     background: #ffffff;
     border-bottom: 1px solid #e5e5e5;
-    padding: 16px 0;
+    padding: 0 16px;
+    height: 57px;
+    flex-shrink: 0;
 }
 
-.header .container {
+.header-content {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    /* Make header content span full viewport width so items sit in the corners */
-    max-width: none;
-    width: 100%;
+    height: 100%;
 }
 
-.logo {
-    font-size: 24px;
-    font-weight: 600;
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+/* Language Selector */
+.lang-selector {
+    position: relative;
+}
+
+.lang-button {
+    width: 40px;
+    height: 40px;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: background-color 0.2s ease;
+}
+
+.lang-button:hover:not(:disabled) {
+    background: #f3f4f6;
+}
+
+.lang-button:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.lang-flag {
+    font-size: 22px;
+    line-height: 1;
+}
+
+.lang-dropdown {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    background: #ffffff;
+    border: 1px solid #e5e5e5;
+    border-radius: 12px;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+    min-width: 160px;
+    z-index: 100;
+    overflow: hidden;
+}
+
+.lang-option {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 14px;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    font-family: inherit;
+    font-size: 14px;
     color: #1a1a1a;
+    text-align: left;
+    transition: background-color 0.15s ease;
+}
+
+.lang-option:hover {
+    background: #f3f4f6;
+}
+
+.lang-option.active {
+    background: #f3f4f6;
+    font-weight: 500;
+}
+
+.lang-name {
+    flex: 1;
 }
 
-.header-controls {
+/* Logo Menu Button */
+.logo-menu-button {
+    width: 40px;
+    height: 40px;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    border-radius: 8px;
     display: flex;
     align-items: center;
-    gap: 16px;
+    justify-content: center;
+    transition: background-color 0.2s ease;
 }
 
-.language-selector {
+.logo-menu-button:hover {
+    background: #f3f4f6;
+}
+
+.logo-icon {
+    width: 28px;
+    height: 28px;
+}
+
+/* Header Dropdown */
+.header-dropdown {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    background: #ffffff;
+    border: 1px solid #e5e5e5;
+    border-radius: 12px;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+    min-width: 220px;
+    z-index: 100;
+    overflow: hidden;
+}
+
+.dropdown-item {
+    padding: 12px 16px;
     display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+.dropdown-status {
+    flex-direction: row;
     align-items: center;
+    gap: 10px;
+    font-size: 14px;
+    color: #1a1a1a;
 }
 
-.language-dropdown {
+.dropdown-divider {
+    height: 1px;
+    background: #e5e5e5;
+}
+
+.dropdown-label {
+    font-size: 12px;
+    color: #6b7280;
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.dropdown-select {
     font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
     font-size: 14px;
     padding: 8px 12px;
@@ -63,8 +492,7 @@ body {
     background: #ffffff;
     color: #1a1a1a;
     cursor: pointer;
-    transition: all 0.2s ease;
-    min-width: 140px;
+    width: 100%;
     appearance: none;
     background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%236b7280' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M6 9l6 6 6-6'/%3E%3C/svg%3E");
     background-repeat: no-repeat;
@@ -72,25 +500,116 @@ body {
     padding-right: 32px;
 }
 
-.language-dropdown:hover:not(:disabled) {
+.dropdown-select:hover:not(:disabled) {
     border-color: #1a1a1a;
 }
 
-.language-dropdown:focus {
+.dropdown-select:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.dropdown-user {
+    gap: 4px;
+}
+
+.dropdown-email {
+    font-size: 14px;
+    color: #1a1a1a;
+    word-break: break-all;
+}
+
+.dropdown-button {
+    cursor: pointer;
+    background: none;
+    border: none;
+    font-family: inherit;
+    font-size: 14px;
+    color: #1a1a1a;
+    text-align: left;
+    transition: background-color 0.15s ease;
+}
+
+.dropdown-button:hover {
+    background: #f3f4f6;
+}
+
+.dropdown-loading {
+    font-size: 14px;
+    color: #6b7280;
+}
+
+/* Dropdown Auth Form */
+.dropdown-auth-form {
+    padding: 12px 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.dropdown-auth-header {
+    font-size: 14px;
+    font-weight: 600;
+    color: #1a1a1a;
+}
+
+.dropdown-auth-error {
+    font-size: 13px;
+    color: #ef4444;
+    background: #fef2f2;
+    padding: 8px 10px;
+    border-radius: 6px;
+}
+
+.dropdown-input {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 10px 12px;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
     outline: none;
+    transition: border-color 0.2s ease;
+}
+
+.dropdown-input:focus {
     border-color: #1a1a1a;
-    box-shadow: 0 0 0 2px rgba(26, 26, 26, 0.1);
 }
 
-.language-dropdown:disabled {
-    opacity: 0.5;
+.dropdown-submit {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 10px 16px;
+    border: none;
+    border-radius: 8px;
+    background: #1a1a1a;
+    color: #ffffff;
+    cursor: pointer;
+    font-weight: 500;
+    transition: background 0.2s ease;
+}
+
+.dropdown-submit:hover:not(:disabled) {
+    background: #333333;
+}
+
+.dropdown-submit:disabled {
+    opacity: 0.6;
     cursor: not-allowed;
 }
 
-.status-indicator {
-    display: flex;
-    align-items: center;
-    gap: 8px;
+.dropdown-toggle-auth {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 13px;
+    padding: 0;
+    border: none;
+    background: none;
+    color: #6b7280;
+    cursor: pointer;
+    text-align: center;
+}
+
+.dropdown-toggle-auth:hover {
+    color: #1a1a1a;
 }
 
 .status-dot {
@@ -115,6 +634,147 @@ body {
     font-weight: 500;
 }
 
+/* Auth Controls */
+.auth-controls {
+    display: flex;
+    align-items: center;
+}
+
+.auth-loading {
+    font-size: 14px;
+    color: #6b7280;
+}
+
+.user-menu {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.user-email {
+    font-size: 13px;
+    color: #6b7280;
+    max-width: 150px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.sign-in-btn,
+.sign-out-btn {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 8px 16px;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    background: #ffffff;
+    color: #1a1a1a;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    font-weight: 500;
+}
+
+.sign-in-btn:hover,
+.sign-out-btn:hover {
+    border-color: #1a1a1a;
+    background: #f9fafb;
+}
+
+.sign-out-btn {
+    padding: 6px 12px;
+    font-size: 13px;
+}
+
+/* Auth Dropdown */
+.auth-dropdown-container {
+    position: relative;
+}
+
+.auth-dropdown {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    background: #ffffff;
+    border: 1px solid #e5e5e5;
+    border-radius: 12px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    padding: 20px;
+    width: 280px;
+    z-index: 100;
+}
+
+.auth-form {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.auth-form h3 {
+    font-size: 16px;
+    font-weight: 600;
+    margin: 0 0 4px 0;
+    color: #1a1a1a;
+}
+
+.auth-form input {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 10px 12px;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    outline: none;
+    transition: border-color 0.2s ease;
+}
+
+.auth-form input:focus {
+    border-color: #1a1a1a;
+}
+
+.auth-error {
+    font-size: 13px;
+    color: #ef4444;
+    background: #fef2f2;
+    padding: 8px 12px;
+    border-radius: 6px;
+}
+
+.auth-submit-btn {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 14px;
+    padding: 10px 16px;
+    border: none;
+    border-radius: 8px;
+    background: #1a1a1a;
+    color: #ffffff;
+    cursor: pointer;
+    font-weight: 500;
+    transition: background 0.2s ease;
+}
+
+.auth-submit-btn:hover:not(:disabled) {
+    background: #333333;
+}
+
+.auth-submit-btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+}
+
+.auth-toggle-btn {
+    font-family: 'Roboto Serif', Georgia, Cambria, 'Times New Roman', serif;
+    font-size: 13px;
+    padding: 0;
+    border: none;
+    background: none;
+    color: #6b7280;
+    cursor: pointer;
+    text-align: center;
+}
+
+.auth-toggle-btn:hover {
+    color: #1a1a1a;
+}
+
 /* Main Layout */
 .main {
     padding: 32px 0;
@@ -142,6 +802,14 @@ body {
     font-size: 20px;
     font-weight: 600;
     color: #1a1a1a;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.section-header-flag {
+    font-size: 20px;
+    line-height: 1;
 }
 
 .card-count {
@@ -249,6 +917,33 @@ body {
     flex-direction: column;
     gap: 16px;
     min-height: 0;
+    position: relative;
+}
+
+/* Chat loading state */
+.chat-loading {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: rgba(255, 255, 255, 0.8);
+    z-index: 10;
+}
+
+.chat-loading-spinner {
+    width: 32px;
+    height: 32px;
+    border: 3px solid #e5e5e5;
+    border-top-color: #1a1a1a;
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
 }
 
 .message {
@@ -568,12 +1263,41 @@ body {
 
 /* Responsive */
 @media (max-width: 768px) {
+    /* Sidebar mobile - slide-out drawer */
+    .sidebar {
+        position: fixed;
+        left: 0;
+        top: 0;
+        bottom: 0;
+        z-index: 50;
+        transform: translateX(-100%);
+        transition: transform 0.3s ease;
+        box-shadow: none;
+    }
+
+    .sidebar.open {
+        transform: translateX(0);
+        box-shadow: 4px 0 24px rgba(0, 0, 0, 0.15);
+    }
+
+    .sidebar-overlay {
+        display: block;
+    }
+
+    .sidebar-close-button {
+        display: flex;
+    }
+
+    .menu-toggle {
+        display: flex;
+    }
+
     .main {
         padding: 16px 0;
         height: calc(100vh - 80px);
         overflow: hidden;
     }
-    
+
     .app-grid {
         grid-template-columns: 1fr;
         grid-template-rows: 1fr 1fr;
@@ -581,7 +1305,7 @@ body {
         height: 100%;
         overflow: hidden;
     }
-    
+
     .chat-section,
     .flashcards-section {
         height: 100%;
@@ -589,12 +1313,12 @@ body {
         overflow: hidden;
         padding: 16px;
     }
-    
+
     .container {
         padding: 0 16px;
         height: 100%;
     }
-    
+
     .messages,
     .flashcards-grid {
         max-height: none;
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 879568b..1a9e0df 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -32,6 +32,20 @@ export interface ConversationHistory {
   messages: ConversationMessage[];
 }
 
+// Multi-conversation support
+export interface ConversationSummary {
+  id: string;
+  title: string;
+  languageCode: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ConversationData {
+  id: string;
+  messages: ConversationMessage[];
+}
+
 // Flashcard
 export interface Flashcard {
   targetWord: string;
@@ -40,6 +54,7 @@ export interface Flashcard {
   mnemonic: string;
   timestamp?: string;
   languageCode?: string;
+  conversationId?: string;
   // Legacy fields for backward compatibility
   spanish?: string;
   word?: string;
@@ -138,6 +153,11 @@ export interface AppState {
 
   // User
   userId: string;
+
+  // Multi-conversation support
+  conversations: ConversationSummary[];
+  currentConversationId: string | null;
+  sidebarOpen: boolean;
 }
 
 // Outgoing WebSocket message
diff --git a/frontend/vitest.config.ts b/frontend/vitest.config.ts
new file mode 100644
index 0000000..5b2ae34
--- /dev/null
+++ b/frontend/vitest.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    include: ['src/__tests__/**/*.test.ts', 'src/__tests__/**/*.test.tsx'],
+    setupFiles: ['./src/__tests__/setup.ts'],
+  },
+});
diff --git a/package-lock.json b/package-lock.json
index ce9bda8..2d4b43a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -25,21 +25,95 @@
         "@types/express": "^4.17.21",
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.12",
+        "@vitest/coverage-v8": "^2.1.0",
         "eslint": "^9.0.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-prettier": "^5.1.3",
         "nodemon": "^3.1.10",
         "pino-pretty": "^13.1.3",
         "prettier": "^3.2.5",
+        "supabase": "^2.70.5",
         "tsx": "^4.7.0",
         "typescript": "^5.3.3",
-        "typescript-eslint": "^8.0.0"
+        "typescript-eslint": "^8.0.0",
+        "vitest": "^2.1.0"
       },
       "engines": {
         "node": ">=20.0.0",
         "npm": ">=9.0.0"
       }
     },
+    "node_modules/@ampproject/remapping": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
+      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
+      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.5"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
+      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
+      "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.25.12",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
@@ -780,6 +854,86 @@
         "node": ">=18.0.0"
       }
     },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@istanbuljs/schema": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",
+      "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -824,6 +978,17 @@
       "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
       "license": "MIT"
     },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/@pkgr/core": {
       "version": "0.2.9",
       "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz",
@@ -901,131 +1066,439 @@
       "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
       "license": "BSD-3-Clause"
     },
-    "node_modules/@tsconfig/node-lts": {
-      "version": "22.0.2",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node-lts/-/node-lts-22.0.2.tgz",
-      "integrity": "sha512-Kgq5yXTvnUnvlhob0xJpOH4na9PWtuFhHSf94MpDwnENWgiFeJKDNANQV2MT1WpXZYkK2WSWfVYKhVkR7bc8TA==",
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.54.0.tgz",
+      "integrity": "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.6",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
-      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.54.0.tgz",
+      "integrity": "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.54.0.tgz",
+      "integrity": "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
     },
-    "node_modules/@types/cors": {
-      "version": "2.8.19",
-      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
-      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.54.0.tgz",
+      "integrity": "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
     },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.54.0.tgz",
+      "integrity": "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
     },
-    "node_modules/@types/express": {
-      "version": "4.17.23",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.23.tgz",
-      "integrity": "sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==",
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.54.0.tgz",
+      "integrity": "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^4.17.33",
-        "@types/qs": "*",
-        "@types/serve-static": "*"
-      }
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
     },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "4.19.6",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
-      "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.54.0.tgz",
+      "integrity": "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
-      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.54.0.tgz",
+      "integrity": "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.54.0.tgz",
+      "integrity": "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/lodash": {
-      "version": "4.17.20",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.20.tgz",
-      "integrity": "sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/lodash.snakecase": {
-      "version": "4.1.9",
-      "resolved": "https://registry.npmjs.org/@types/lodash.snakecase/-/lodash.snakecase-4.1.9.tgz",
-      "integrity": "sha512-emBZJUiNlo+QPXr1junMKXwzHJK9zbFvTVdyAoorFcm1YRsbzkZCYPTVMM9AW+dlnA6utG7vpfvOs8alxv/TMw==",
       "license": "MIT",
-      "dependencies": {
-        "@types/lodash": "*"
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@types/mime": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
-      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.54.0.tgz",
+      "integrity": "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/node": {
-      "version": "20.19.25",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.25.tgz",
-      "integrity": "sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==",
       "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.21.0"
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@types/node-fetch": {
-      "version": "2.6.13",
-      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz",
-      "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==",
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.54.0.tgz",
+      "integrity": "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "form-data": "^4.0.4"
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.54.0.tgz",
+      "integrity": "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.54.0.tgz",
+      "integrity": "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.54.0.tgz",
+      "integrity": "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.54.0.tgz",
+      "integrity": "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.54.0.tgz",
+      "integrity": "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.54.0.tgz",
+      "integrity": "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.54.0.tgz",
+      "integrity": "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.54.0.tgz",
+      "integrity": "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.54.0.tgz",
+      "integrity": "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@tsconfig/node-lts": {
+      "version": "22.0.2",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node-lts/-/node-lts-22.0.2.tgz",
+      "integrity": "sha512-Kgq5yXTvnUnvlhob0xJpOH4na9PWtuFhHSf94MpDwnENWgiFeJKDNANQV2MT1WpXZYkK2WSWfVYKhVkR7bc8TA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.6",
+      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/express": {
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.23.tgz",
+      "integrity": "sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.19.6",
+      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
+      "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/lodash": {
+      "version": "4.17.20",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.20.tgz",
+      "integrity": "sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/lodash.snakecase": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@types/lodash.snakecase/-/lodash.snakecase-4.1.9.tgz",
+      "integrity": "sha512-emBZJUiNlo+QPXr1junMKXwzHJK9zbFvTVdyAoorFcm1YRsbzkZCYPTVMM9AW+dlnA6utG7vpfvOs8alxv/TMw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/lodash": "*"
+      }
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
+      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.25",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.25.tgz",
+      "integrity": "sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/node-fetch": {
+      "version": "2.6.13",
+      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz",
+      "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "form-data": "^4.0.4"
+      }
     },
     "node_modules/@types/protobufjs": {
       "version": "6.0.0",
@@ -1442,25 +1915,196 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
-    "node_modules/@zod/core": {
-      "version": "0.11.6",
-      "resolved": "https://registry.npmjs.org/@zod/core/-/core-0.11.6.tgz",
-      "integrity": "sha512-03Bv82fFSfjDAvMfdHHdGSS6SOJs0iCcJlWJv1kJHRtoTT02hZpyip/2Lk6oo4l4FtjuwTrsEQTwg/LD8I7dJA==",
+    "node_modules/@vitest/coverage-v8": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-2.1.9.tgz",
+      "integrity": "sha512-Z2cOr0ksM00MpEfyVE8KXIYPEcBFxdbLSs56L8PO0QQMxt/6bDj45uQfxoc96v05KW3clk7vvgP0qfDit9DmfQ==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@ampproject/remapping": "^2.3.0",
+        "@bcoe/v8-coverage": "^0.2.3",
+        "debug": "^4.3.7",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-lib-source-maps": "^5.0.6",
+        "istanbul-reports": "^3.1.7",
+        "magic-string": "^0.30.12",
+        "magicast": "^0.3.5",
+        "std-env": "^3.8.0",
+        "test-exclude": "^7.0.1",
+        "tinyrainbow": "^1.2.0"
+      },
       "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@vitest/browser": "2.1.9",
+        "vitest": "2.1.9"
+      },
+      "peerDependenciesMeta": {
+        "@vitest/browser": {
+          "optional": true
+        }
       }
     },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+    "node_modules/@vitest/coverage-v8/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "event-target-shim": "^5.0.0"
+        "ms": "^2.1.3"
       },
       "engines": {
-        "node": ">=6.5"
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/coverage-v8/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitest/expect": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
+      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
+      "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.12"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
+      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
+      "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "2.1.9",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
+      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
+      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^3.0.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
+      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "loupe": "^3.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@zod/core": {
+      "version": "0.11.6",
+      "resolved": "https://registry.npmjs.org/@zod/core/-/core-0.11.6.tgz",
+      "integrity": "sha512-03Bv82fFSfjDAvMfdHHdGSS6SOJs0iCcJlWJv1kJHRtoTT02hZpyip/2Lk6oo4l4FtjuwTrsEQTwg/LD8I7dJA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
       }
     },
     "node_modules/accepts": {
@@ -1499,6 +2143,16 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/agentkeepalive": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz",
@@ -1555,6 +2209,32 @@
         "sql.js": "^0.5.0"
       }
     },
+    "node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
@@ -1594,6 +2274,16 @@
         "node": ">=18"
       }
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -1651,6 +2341,23 @@
       ],
       "license": "MIT"
     },
+    "node_modules/bin-links": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/bin-links/-/bin-links-6.0.0.tgz",
+      "integrity": "sha512-X4CiKlcV2GjnCMwnKAfbVWpHa++65th9TuzAEYtZoATiOE2DQKhSp4CJlyLoTqdhBKlXjpXjCTYPNNFS33Fi6w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cmd-shim": "^8.0.0",
+        "npm-normalize-package-bin": "^5.0.0",
+        "proc-log": "^6.0.0",
+        "read-cmd-shim": "^6.0.0",
+        "write-file-atomic": "^7.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
@@ -1786,6 +2493,16 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/call-bind": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
@@ -1843,6 +2560,23 @@
         "node": ">=6"
       }
     },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -1904,6 +2638,16 @@
         "node": "*"
       }
     },
+    "node_modules/check-error": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
     "node_modules/chokidar": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
@@ -1929,6 +2673,26 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/cmd-shim": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/cmd-shim/-/cmd-shim-8.0.0.tgz",
+      "integrity": "sha512-Jk/BK6NCapZ58BKUxlSI+ouKRbjH1NLZCgJkYoab+vEHUY3f6OzpNBN9u7HFSv9J6TRDGs4PLOHezoKGaFRSCA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2058,6 +2822,16 @@
         "node": "*"
       }
     },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/dateformat": {
       "version": "4.6.3",
       "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-4.6.3.tgz",
@@ -2173,6 +2947,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -2251,12 +3035,26 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
       "license": "MIT"
     },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/encodeurl": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
@@ -2293,6 +3091,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -2631,6 +3436,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -2659,6 +3474,16 @@
         "node": ">=6"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/express": {
       "version": "4.21.2",
       "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
@@ -2798,6 +3623,40 @@
         "pend": "~1.2.0"
       }
     },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/fetch-blob/node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/file-entry-cache": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -2904,6 +3763,23 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -2939,6 +3815,19 @@
         "node": ">= 12.20"
       }
     },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -3050,6 +3939,27 @@
         "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
       }
     },
+    "node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -3063,18 +3973,44 @@
         "node": ">= 6"
       }
     },
-    "node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+    "node_modules/glob/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     },
     "node_modules/gopd": {
       "version": "1.2.0",
@@ -3199,6 +4135,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/http-errors": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
@@ -3215,6 +4158,45 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/humanize-ms": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
@@ -3356,6 +4338,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -3422,6 +4414,140 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-source-maps": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz",
+      "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.23",
+        "debug": "^4.1.1",
+        "istanbul-lib-coverage": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-source-maps/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/istanbul-lib-source-maps/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
     "node_modules/joycon": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
@@ -3545,6 +4671,42 @@
       "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
       "license": "Apache-2.0"
     },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/magicast": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.3.5.tgz",
+      "integrity": "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.25.4",
+        "@babel/types": "^7.25.4",
+        "source-map-js": "^1.2.0"
+      }
+    },
     "node_modules/make-dir": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz",
@@ -3682,12 +4844,54 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
       "license": "MIT"
     },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
     "node_modules/natural-compare": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
@@ -3817,6 +5021,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/npm-normalize-package-bin": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-5.0.0.tgz",
+      "integrity": "sha512-CJi3OS4JLsNMmr2u07OJlhcrPxCeOeP/4xq67aWNai6TNWWbTrlNDgl8NcFKVlcBKp18GPj+EzbNIgrBfZhsag==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -3918,6 +5132,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
     "node_modules/pako": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
@@ -3966,18 +5187,59 @@
         "node": ">=8"
       }
     },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/path-to-regexp": {
       "version": "0.1.12",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
       "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
       "license": "MIT"
     },
+    "node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
     "node_modules/pend": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
       "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
       "license": "MIT"
     },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -4115,15 +5377,44 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
     },
     "node_modules/prettier": {
       "version": "3.6.2",
@@ -4154,6 +5445,16 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/proc-log": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-6.1.0.tgz",
+      "integrity": "sha512-iG+GYldRf2BQ0UDUAd6JQ/RwzaQy6mXmsk/IzlYyal4A4SNFw54MeH4/tLkF4I5WoWG9SQwuqWzS99jaFQHBuQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
@@ -4307,6 +5608,16 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/read-cmd-shim": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-6.0.0.tgz",
+      "integrity": "sha512-1zM5HuOfagXCBWMN83fuFI/x+T/UhZ7k+KIzhrHXcQoeX5+7gmaDYjELQHmmzIodumBHeByBJT4QYS7ufAgs7A==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/readable-stream": {
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
@@ -4390,6 +5701,48 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rollup": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.54.0.tgz",
+      "integrity": "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.54.0",
+        "@rollup/rollup-android-arm64": "4.54.0",
+        "@rollup/rollup-darwin-arm64": "4.54.0",
+        "@rollup/rollup-darwin-x64": "4.54.0",
+        "@rollup/rollup-freebsd-arm64": "4.54.0",
+        "@rollup/rollup-freebsd-x64": "4.54.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.54.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.54.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.54.0",
+        "@rollup/rollup-linux-arm64-musl": "4.54.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.54.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.54.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-musl": "4.54.0",
+        "@rollup/rollup-openharmony-arm64": "4.54.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.54.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.54.0",
+        "@rollup/rollup-win32-x64-gnu": "4.54.0",
+        "@rollup/rollup-win32-x64-msvc": "4.54.0",
+        "fsevents": "~2.3.2"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -4683,6 +6036,26 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/simple-update-notifier": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
@@ -4705,6 +6078,16 @@
         "atomic-sleep": "^1.0.0"
       }
     },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/split2": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
@@ -4720,6 +6103,13 @@
       "integrity": "sha512-E80yfgPSOvkbEweROP8kUg+8YfvuWht2RYhPMngkJuKD7IgFVWPP/pAhSAUVZMY9UPf5m10Pi0yW9e4CRnmYGg==",
       "license": "MIT"
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/statuses": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
@@ -4729,6 +6119,13 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/string_decoder": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
@@ -4744,6 +6141,110 @@
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "license": "MIT"
     },
+    "node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string-width-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
+      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-dirs": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz",
@@ -4766,6 +6267,45 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/supabase": {
+      "version": "2.70.5",
+      "resolved": "https://registry.npmjs.org/supabase/-/supabase-2.70.5.tgz",
+      "integrity": "sha512-HtMGtYbcL9dxi2Yz4eGWWlxl9nQi76pOyGgCTBeE67p5AeIlv+KJhDOR8oinaNfHHMPKk0Uo1WW7Kxyrz+tdgg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "bin-links": "^6.0.0",
+        "https-proxy-agent": "^7.0.2",
+        "node-fetch": "^3.3.2",
+        "tar": "7.5.2"
+      },
+      "bin": {
+        "supabase": "bin/supabase"
+      },
+      "engines": {
+        "npm": ">=8"
+      }
+    },
+    "node_modules/supabase/node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
     "node_modules/supports-color": {
       "version": "5.5.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
@@ -4795,6 +6335,23 @@
         "url": "https://opencollective.com/synckit"
       }
     },
+    "node_modules/tar": {
+      "version": "7.5.2",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.2.tgz",
+      "integrity": "sha512-7NyxrTE4Anh8km8iEy7o0QYPs+0JKBTj5ZaqHg6B39erLg0qYXN3BijtShwbsNSvQ+LN75+KV+C4QR/f6Gwnpg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.1.0",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/tar-stream": {
       "version": "1.6.2",
       "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.2.tgz",
@@ -4813,6 +6370,47 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/test-exclude": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz",
+      "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@istanbuljs/schema": "^0.1.2",
+        "glob": "^10.4.1",
+        "minimatch": "^9.0.4"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/test-exclude/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/test-exclude/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/thread-stream": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
@@ -4828,6 +6426,50 @@
       "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
       "license": "MIT"
     },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
+      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
+      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/to-buffer": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.1.tgz",
@@ -5076,39 +6718,668 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/web-streams-polyfill": {
-      "version": "4.0.0-beta.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
-      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "license": "MIT",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "isexe": "^2.0.0"
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
+      "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.3.7",
+        "es-module-lexer": "^1.5.4",
+        "pathe": "^1.1.2",
+        "vite": "^5.0.0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vite-node/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vite/node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
+      "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "2.1.9",
+        "@vitest/mocker": "2.1.9",
+        "@vitest/pretty-format": "^2.1.9",
+        "@vitest/runner": "2.1.9",
+        "@vitest/snapshot": "2.1.9",
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "debug": "^4.3.7",
+        "expect-type": "^1.1.0",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2",
+        "std-env": "^3.8.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.1",
+        "tinypool": "^1.0.1",
+        "tinyrainbow": "^1.2.0",
+        "vite": "^5.0.0",
+        "vite-node": "2.1.9",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "2.1.9",
+        "@vitest/ui": "2.1.9",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "4.0.0-beta.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
+      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
       },
       "bin": {
         "node-which": "bin/node-which"
@@ -5138,6 +7409,23 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -5148,12 +7436,124 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "license": "ISC"
     },
+    "node_modules/write-file-atomic": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-7.0.0.tgz",
+      "integrity": "sha512-YnlPC6JqnZl6aO4uRc+dx5PHguiR9S6WeoLtpxNT9wIG+BDya7ZNE1q7KOjVgaA73hKhKLpVPgJ5QA9THQ5BRg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
     "node_modules/ws": {
       "version": "8.18.3",
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
@@ -5184,6 +7584,16 @@
         "node": ">=0.4"
       }
     },
+    "node_modules/yallist": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/yauzl": {
       "version": "2.10.0",
       "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
diff --git a/package.json b/package.json
index 3a01911..4ae5a88 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,10 @@
     "start": "node dist/backend/server.js",
     "dev": "nodemon --exec \"tsx backend/server.ts\" --ext ts",
     "test-stt": "tsx backend/test-stt.ts",
+    "test": "npm run test:backend && npm run test:frontend",
+    "test:backend": "vitest run --config backend/vitest.config.ts",
+    "test:frontend": "npm run test --prefix frontend",
+    "test:watch": "vitest --config backend/vitest.config.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
@@ -28,6 +32,7 @@
     "npm": ">=9.0.0"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.0",
     "@eslint/js": "^9.0.0",
     "@tsconfig/node-lts": "^22.0.2",
     "@types/cors": "^2.8.19",
@@ -40,9 +45,11 @@
     "nodemon": "^3.1.10",
     "pino-pretty": "^13.1.3",
     "prettier": "^3.2.5",
+    "supabase": "^2.70.5",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^8.0.0"
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^2.1.0"
   },
   "dependencies": {
     "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
diff --git a/supabase/config.toml b/supabase/config.toml
new file mode 100644
index 0000000..3cc2184
--- /dev/null
+++ b/supabase/config.toml
@@ -0,0 +1,10 @@
+[api]
+enabled = true
+port = 54321
+
+[db]
+port = 54322
+
+[studio]
+enabled = true
+port = 54323
diff --git a/supabase/migrations/00001_schema.sql b/supabase/migrations/00001_schema.sql
new file mode 100644
index 0000000..6b99092
--- /dev/null
+++ b/supabase/migrations/00001_schema.sql
@@ -0,0 +1,62 @@
+-- Inworld Language Tutor - Supabase Schema
+-- Run this in your Supabase SQL Editor to set up the database
+
+-- User preferences (language preference)
+create table public.user_preferences (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null unique,
+  language_code text default 'es' not null,
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+-- Conversations (multi-conversation support, per language)
+create table public.conversations (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+  language_code text not null,
+  title text not null,
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+-- Conversation messages (belong to a conversation)
+create table public.conversation_messages (
+  id uuid primary key default gen_random_uuid(),
+  conversation_id uuid references public.conversations(id) on delete cascade not null,
+  role text check (role in ('user', 'assistant')) not null,
+  content text not null,
+  created_at timestamptz default now() not null
+);
+
+-- Flashcards (per user per conversation)
+create table public.flashcards (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+  language_code text not null,
+  conversation_id uuid references public.conversations(id) on delete cascade,
+  target_word text not null,
+  english text not null,
+  example text,
+  mnemonic text,
+  created_at timestamptz default now() not null,
+  unique(user_id, conversation_id, target_word)
+);
+
+-- Indexes
+create index idx_conversations_user_lang on public.conversations(user_id, language_code, updated_at desc);
+create index idx_messages_conversation on public.conversation_messages(conversation_id, created_at);
+create index idx_flashcards_conversation on public.flashcards(user_id, conversation_id);
+
+-- Enable Row Level Security
+alter table public.user_preferences enable row level security;
+alter table public.conversations enable row level security;
+alter table public.conversation_messages enable row level security;
+alter table public.flashcards enable row level security;
+
+-- RLS Policies (users can only access their own data)
+create policy "Users manage own preferences" on public.user_preferences for all using (auth.uid() = user_id);
+create policy "Users manage own conversations" on public.conversations for all using (auth.uid() = user_id);
+create policy "Users manage own messages" on public.conversation_messages for all
+  using (conversation_id in (select id from public.conversations where user_id = auth.uid()));
+create policy "Users manage own flashcards" on public.flashcards for all using (auth.uid() = user_id);

From 1ae0ce8136493122bbbde0e120cfa95576a2ffbe Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Fri, 2 Jan 2026 19:35:17 -0800
Subject: [PATCH 24/49] db fixes and lint fixes

---
 README.md                                     |  24 +-
 backend/server.ts                             |   9 +-
 backend/services/shutdown.ts                  |   6 +-
 backend/services/websocket-handler.ts         | 114 ++++---
 eslint.config.mjs                             |   2 +-
 .../src/__tests__/services/Storage.test.ts    |  66 +++-
 frontend/src/components/ChatSection.tsx       |   6 +-
 frontend/src/components/Header.tsx            | 143 +++++----
 frontend/src/components/Sidebar.tsx           |  25 +-
 frontend/src/context/AppContext.tsx           | 299 ++++++++++++++----
 frontend/src/context/AuthContext.tsx          |  20 +-
 frontend/src/services/HybridStorage.ts        | 131 +++++++-
 frontend/src/services/Storage.ts              |  37 ++-
 frontend/src/services/SupabaseStorage.ts      |  33 +-
 frontend/tsconfig.app.json                    |   9 +-
 tsconfig.eslint.json                          |   5 +
 16 files changed, 691 insertions(+), 238 deletions(-)
 create mode 100644 tsconfig.eslint.json

diff --git a/README.md b/README.md
index 4e56458..4cc8475 100644
--- a/README.md
+++ b/README.md
@@ -40,10 +40,10 @@ INWORLD_API_KEY=your_inworld_base64_key
 ASSEMBLY_AI_API_KEY=your_assemblyai_key
 ```
 
-| Service | Get Key From | Purpose |
-|---------|-------------|---------|
-| **Inworld** | [platform.inworld.ai](https://platform.inworld.ai/) | AI conversations (Base64 API key) |
-| **AssemblyAI** | [assemblyai.com](https://www.assemblyai.com/) | Speech-to-text |
+| Service        | Get Key From                                        | Purpose                           |
+| -------------- | --------------------------------------------------- | --------------------------------- |
+| **Inworld**    | [platform.inworld.ai](https://platform.inworld.ai/) | AI conversations (Base64 API key) |
+| **AssemblyAI** | [assemblyai.com](https://www.assemblyai.com/)       | Speech-to-text                    |
 
 ### Step 4: Run the Application
 
@@ -132,14 +132,14 @@ The app uses a real-time audio streaming architecture:
 
 ## Environment Variables Reference
 
-| Variable | Required | Description |
-|----------|----------|-------------|
-| `INWORLD_API_KEY` | Yes | Inworld AI Base64 API key |
-| `ASSEMBLY_AI_API_KEY` | Yes | AssemblyAI API key |
-| `PORT` | No | Server port (default: 3000) |
-| `LOG_LEVEL` | No | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
-| `NODE_ENV` | No | `development` or `production` |
-| `ASSEMBLY_AI_EAGERNESS` | No | Turn detection: `low`, `medium`, `high` (default: medium) |
+| Variable                | Required | Description                                                        |
+| ----------------------- | -------- | ------------------------------------------------------------------ |
+| `INWORLD_API_KEY`       | Yes      | Inworld AI Base64 API key                                          |
+| `ASSEMBLY_AI_API_KEY`   | Yes      | AssemblyAI API key                                                 |
+| `PORT`                  | No       | Server port (default: 3000)                                        |
+| `LOG_LEVEL`             | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
+| `NODE_ENV`              | No       | `development` or `production`                                      |
+| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: medium)          |
 
 ## Testing
 
diff --git a/backend/server.ts b/backend/server.ts
index dfcafea..c46b48f 100644
--- a/backend/server.ts
+++ b/backend/server.ts
@@ -25,7 +25,10 @@ import { serverLogger as logger } from './utils/logger.js';
 
 // Import services
 import { initTelemetry } from './services/telemetry.js';
-import { initializeGraph, exportGraphConfigs } from './services/graph-service.js';
+import {
+  initializeGraph,
+  exportGraphConfigs,
+} from './services/graph-service.js';
 import { setupWebSocketHandlers } from './services/websocket-handler.js';
 import { apiRouter } from './services/api-routes.js';
 import { createGracefulShutdown } from './services/shutdown.js';
@@ -54,7 +57,9 @@ initTelemetry();
 // API routes
 app.use('/api', apiRouter);
 app.get('/health', (_req, res) => {
-  res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() });
+  res
+    .status(200)
+    .json({ status: 'healthy', timestamp: new Date().toISOString() });
 });
 
 // Static files
diff --git a/backend/services/shutdown.ts b/backend/services/shutdown.ts
index ca03fbe..a18ebd8 100644
--- a/backend/services/shutdown.ts
+++ b/backend/services/shutdown.ts
@@ -9,7 +9,11 @@ import { WebSocketServer } from 'ws';
 import { stopInworldRuntime } from '@inworld/runtime';
 
 import { serverLogger as logger } from '../utils/logger.js';
-import { connectionManagers, setShuttingDown, isShuttingDown } from './state.js';
+import {
+  connectionManagers,
+  setShuttingDown,
+  isShuttingDown,
+} from './state.js';
 import { destroyGraph } from './graph-service.js';
 
 export function createGracefulShutdown(
diff --git a/backend/services/websocket-handler.ts b/backend/services/websocket-handler.ts
index 1e38400..1b94df5 100644
--- a/backend/services/websocket-handler.ts
+++ b/backend/services/websocket-handler.ts
@@ -61,7 +61,9 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
     connectionManagers.set(connectionId, connectionManager);
     flashcardProcessors.set(connectionId, flashcardProcessor);
     feedbackProcessors.set(connectionId, feedbackProcessor);
-    connectionAttributes.set(connectionId, { languageCode: defaultLanguageCode });
+    connectionAttributes.set(connectionId, {
+      languageCode: defaultLanguageCode,
+    });
 
     // Set up flashcard generation callback
     connectionManager.setFlashcardCallback(async (messages) => {
@@ -109,48 +111,53 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
     });
 
     // Set up feedback generation callback
-    connectionManager.setFeedbackCallback(async (messages, currentTranscript) => {
-      if (isShuttingDown()) {
-        logger.debug(
-          { connectionId },
-          'skipping_feedback_generation_shutting_down'
-        );
-        return;
-      }
-
-      try {
-        const attrs = connectionAttributes.get(connectionId) || {};
-        const userAttributes: Record<string, string> = {
-          timezone: attrs.timezone || '',
-        };
-
-        const targetingKey = attrs.userId || connectionId;
-        const userContext = {
-          attributes: userAttributes,
-          targetingKey,
-        };
-
-        const feedback = await feedbackProcessor.generateFeedback(
-          messages,
-          currentTranscript,
-          userContext
-        );
-
-        if (feedback) {
-          ws.send(
-            JSON.stringify({
-              type: 'feedback_generated',
-              messageContent: currentTranscript,
-              feedback,
-            })
+    connectionManager.setFeedbackCallback(
+      async (messages, currentTranscript) => {
+        if (isShuttingDown()) {
+          logger.debug(
+            { connectionId },
+            'skipping_feedback_generation_shutting_down'
           );
+          return;
         }
-      } catch (error) {
-        if (!isShuttingDown()) {
-          logger.error({ err: error, connectionId }, 'feedback_generation_error');
+
+        try {
+          const attrs = connectionAttributes.get(connectionId) || {};
+          const userAttributes: Record<string, string> = {
+            timezone: attrs.timezone || '',
+          };
+
+          const targetingKey = attrs.userId || connectionId;
+          const userContext = {
+            attributes: userAttributes,
+            targetingKey,
+          };
+
+          const feedback = await feedbackProcessor.generateFeedback(
+            messages,
+            currentTranscript,
+            userContext
+          );
+
+          if (feedback) {
+            ws.send(
+              JSON.stringify({
+                type: 'feedback_generated',
+                messageContent: currentTranscript,
+                feedback,
+              })
+            );
+          }
+        } catch (error) {
+          if (!isShuttingDown()) {
+            logger.error(
+              { err: error, connectionId },
+              'feedback_generation_error'
+            );
+          }
         }
       }
-    });
+    );
 
     // Start the graph for this connection
     try {
@@ -251,7 +258,11 @@ function handleLanguageChange(
     newLanguageCode = requestedCode;
   } else if (requestedCode) {
     logger.warn(
-      { connectionId, invalidCode: requestedCode, fallback: DEFAULT_LANGUAGE_CODE },
+      {
+        connectionId,
+        invalidCode: requestedCode,
+        fallback: DEFAULT_LANGUAGE_CODE,
+      },
       'invalid_language_code_using_default'
     );
   }
@@ -319,7 +330,16 @@ function handleUserContext(
 
 function handleFlashcardClicked(
   connectionId: string,
-  message: { card?: { id?: string; targetWord?: string; spanish?: string; word?: string; english?: string; translation?: string } }
+  message: {
+    card?: {
+      id?: string;
+      targetWord?: string;
+      spanish?: string;
+      word?: string;
+      english?: string;
+      translation?: string;
+    };
+  }
 ): void {
   const card = message.card;
   if (!card || typeof card !== 'object') {
@@ -338,10 +358,7 @@ function handleFlashcardClicked(
       languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
     });
   } catch (error) {
-    logger.error(
-      { err: error, connectionId },
-      'flashcard_click_record_error'
-    );
+    logger.error({ err: error, connectionId }, 'flashcard_click_record_error');
   }
 }
 
@@ -358,7 +375,12 @@ function handleTextMessage(
   }
   if (text.length > 200) {
     logger.warn({ connectionId, length: text.length }, 'text_message_too_long');
-    ws.send(JSON.stringify({ type: 'error', message: 'Text message too long (max 200 chars)' }));
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        message: 'Text message too long (max 200 chars)',
+      })
+    );
     return;
   }
   connectionManager.sendTextMessage(text.trim());
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 358af7a..53b9311 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -18,7 +18,7 @@ export default [
     languageOptions: {
       parser: tseslint.parser,
       parserOptions: {
-        project: true,
+        project: './tsconfig.eslint.json',
         tsconfigRootDir: __dirname,
       },
     },
diff --git a/frontend/src/__tests__/services/Storage.test.ts b/frontend/src/__tests__/services/Storage.test.ts
index 4093391..0eaf070 100644
--- a/frontend/src/__tests__/services/Storage.test.ts
+++ b/frontend/src/__tests__/services/Storage.test.ts
@@ -167,8 +167,16 @@ describe('Storage', () => {
     it('saves and retrieves conversation messages', () => {
       const conv = storage.createConversation('es');
       const messages = [
-        { role: 'user' as const, content: 'Hola', timestamp: new Date().toISOString() },
-        { role: 'assistant' as const, content: '¡Hola!', timestamp: new Date().toISOString() },
+        {
+          role: 'user' as const,
+          content: 'Hola',
+          timestamp: new Date().toISOString(),
+        },
+        {
+          role: 'assistant' as const,
+          content: '¡Hola!',
+          timestamp: new Date().toISOString(),
+        },
       ];
 
       storage.saveConversation(conv.id, messages, 'es');
@@ -214,7 +222,12 @@ describe('Storage', () => {
       storage.addFlashcards(cards1 as any, 'es');
 
       const cards2 = [
-        { targetWord: 'hola', english: 'hello again', example: '', mnemonic: '' },
+        {
+          targetWord: 'hola',
+          english: 'hello again',
+          example: '',
+          mnemonic: '',
+        },
       ];
       const result = storage.addFlashcards(cards2 as any, 'es');
 
@@ -244,7 +257,14 @@ describe('Storage', () => {
       // Add 110 flashcards
       for (let i = 0; i < 110; i++) {
         storage.addFlashcards(
-          [{ targetWord: `word${i}`, english: `translation${i}`, example: '', mnemonic: '' }] as any,
+          [
+            {
+              targetWord: `word${i}`,
+              english: `translation${i}`,
+              example: '',
+              mnemonic: '',
+            },
+          ] as any,
           'es'
         );
       }
@@ -257,7 +277,9 @@ describe('Storage', () => {
   describe('clearFlashcards', () => {
     it('clears flashcards for a language', () => {
       storage.addFlashcards(
-        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        [
+          { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+        ] as any,
         'es'
       );
       storage.clearFlashcards('es');
@@ -268,11 +290,20 @@ describe('Storage', () => {
 
     it('does not affect flashcards for other languages', () => {
       storage.addFlashcards(
-        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        [
+          { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+        ] as any,
         'es'
       );
       storage.addFlashcards(
-        [{ targetWord: 'bonjour', english: 'hello', example: '', mnemonic: '' }] as any,
+        [
+          {
+            targetWord: 'bonjour',
+            english: 'hello',
+            example: '',
+            mnemonic: '',
+          },
+        ] as any,
         'fr'
       );
 
@@ -303,19 +334,32 @@ describe('Storage', () => {
 
       storage.addFlashcardsForConversation(
         conv1.id,
-        [{ targetWord: 'hola', english: 'hello', example: '', mnemonic: '' }] as any,
+        [
+          { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
+        ] as any,
         'es'
       );
       storage.addFlashcardsForConversation(
         conv2.id,
-        [{ targetWord: 'adios', english: 'goodbye', example: '', mnemonic: '' }] as any,
+        [
+          {
+            targetWord: 'adios',
+            english: 'goodbye',
+            example: '',
+            mnemonic: '',
+          },
+        ] as any,
         'es'
       );
 
       expect(storage.getFlashcardsForConversation(conv1.id).length).toBe(1);
-      expect(storage.getFlashcardsForConversation(conv1.id)[0].targetWord).toBe('hola');
+      expect(storage.getFlashcardsForConversation(conv1.id)[0].targetWord).toBe(
+        'hola'
+      );
       expect(storage.getFlashcardsForConversation(conv2.id).length).toBe(1);
-      expect(storage.getFlashcardsForConversation(conv2.id)[0].targetWord).toBe('adios');
+      expect(storage.getFlashcardsForConversation(conv2.id)[0].targetWord).toBe(
+        'adios'
+      );
     });
   });
 
diff --git a/frontend/src/components/ChatSection.tsx b/frontend/src/components/ChatSection.tsx
index 012d489..89f9ee9 100644
--- a/frontend/src/components/ChatSection.tsx
+++ b/frontend/src/components/ChatSection.tsx
@@ -30,9 +30,11 @@ export function ChatSection() {
 
   // Get the flag for the current conversation or selected language
   const getCurrentFlag = (): string => {
-    const currentConversation = conversations.find(c => c.id === currentConversationId);
+    const currentConversation = conversations.find(
+      (c) => c.id === currentConversationId
+    );
     const langCode = currentConversation?.languageCode || currentLanguage;
-    const lang = availableLanguages.find(l => l.code === langCode);
+    const lang = availableLanguages.find((l) => l.code === langCode);
     return lang?.flag || '🌐';
   };
 
diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index 620b55a..e48c1c8 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -112,77 +112,90 @@ export function Header() {
 
                 {/* Auth Section */}
                 {isConfigured && (
-                <>
-                  <div className="dropdown-divider" />
-                  {isLoading ? (
-                    <div className="dropdown-item dropdown-loading">Loading...</div>
-                  ) : user ? (
-                    <>
-                      <div className="dropdown-item dropdown-user">
-                        <span className="dropdown-label">Signed in as</span>
-                        <span className="dropdown-email">{user.email}</span>
+                  <>
+                    <div className="dropdown-divider" />
+                    {isLoading ? (
+                      <div className="dropdown-item dropdown-loading">
+                        Loading...
                       </div>
+                    ) : user ? (
+                      <>
+                        <div className="dropdown-item dropdown-user">
+                          <span className="dropdown-label">Signed in as</span>
+                          <span className="dropdown-email">{user.email}</span>
+                        </div>
+                        <button
+                          className="dropdown-item dropdown-button"
+                          onClick={handleSignOut}
+                        >
+                          Sign Out
+                        </button>
+                      </>
+                    ) : !showAuthForm ? (
                       <button
                         className="dropdown-item dropdown-button"
-                        onClick={handleSignOut}
+                        onClick={() => setShowAuthForm(true)}
                       >
-                        Sign Out
+                        Sign In
                       </button>
-                    </>
-                  ) : !showAuthForm ? (
-                    <button
-                      className="dropdown-item dropdown-button"
-                      onClick={() => setShowAuthForm(true)}
-                    >
-                      Sign In
-                    </button>
-                  ) : (
-                    <form onSubmit={handleSubmit} className="dropdown-auth-form">
-                      <div className="dropdown-auth-header">
-                        {isSignUp ? 'Create Account' : 'Sign In'}
-                      </div>
-                      {error && <div className="dropdown-auth-error">{error}</div>}
-                      <input
-                        type="email"
-                        placeholder="Email"
-                        value={email}
-                        onChange={(e) => setEmail(e.target.value)}
-                        required
-                        autoComplete="email"
-                        className="dropdown-input"
-                      />
-                      <input
-                        type="password"
-                        placeholder="Password"
-                        value={password}
-                        onChange={(e) => setPassword(e.target.value)}
-                        required
-                        minLength={6}
-                        autoComplete={isSignUp ? 'new-password' : 'current-password'}
-                        className="dropdown-input"
-                      />
-                      <button
-                        type="submit"
-                        className="dropdown-submit"
-                        disabled={submitting}
-                      >
-                        {submitting ? '...' : isSignUp ? 'Create Account' : 'Sign In'}
-                      </button>
-                      <button
-                        type="button"
-                        className="dropdown-toggle-auth"
-                        onClick={toggleAuthMode}
+                    ) : (
+                      <form
+                        onSubmit={handleSubmit}
+                        className="dropdown-auth-form"
                       >
-                        {isSignUp
-                          ? 'Have an account? Sign In'
-                          : 'Need an account? Sign Up'}
-                      </button>
-                    </form>
-                  )}
-                </>
-              )}
-            </div>
-          )}
+                        <div className="dropdown-auth-header">
+                          {isSignUp ? 'Create Account' : 'Sign In'}
+                        </div>
+                        {error && (
+                          <div className="dropdown-auth-error">{error}</div>
+                        )}
+                        <input
+                          type="email"
+                          placeholder="Email"
+                          value={email}
+                          onChange={(e) => setEmail(e.target.value)}
+                          required
+                          autoComplete="email"
+                          className="dropdown-input"
+                        />
+                        <input
+                          type="password"
+                          placeholder="Password"
+                          value={password}
+                          onChange={(e) => setPassword(e.target.value)}
+                          required
+                          minLength={6}
+                          autoComplete={
+                            isSignUp ? 'new-password' : 'current-password'
+                          }
+                          className="dropdown-input"
+                        />
+                        <button
+                          type="submit"
+                          className="dropdown-submit"
+                          disabled={submitting}
+                        >
+                          {submitting
+                            ? '...'
+                            : isSignUp
+                              ? 'Create Account'
+                              : 'Sign In'}
+                        </button>
+                        <button
+                          type="button"
+                          className="dropdown-toggle-auth"
+                          onClick={toggleAuthMode}
+                        >
+                          {isSignUp
+                            ? 'Have an account? Sign In'
+                            : 'Need an account? Sign Up'}
+                        </button>
+                      </form>
+                    )}
+                  </>
+                )}
+              </div>
+            )}
           </div>
         </div>
       </div>
diff --git a/frontend/src/components/Sidebar.tsx b/frontend/src/components/Sidebar.tsx
index e70823d..6f30a3c 100644
--- a/frontend/src/components/Sidebar.tsx
+++ b/frontend/src/components/Sidebar.tsx
@@ -11,7 +11,13 @@ export function Sidebar() {
     toggleSidebar,
     changeLanguage,
   } = useApp();
-  const { conversations, currentConversationId, sidebarOpen, availableLanguages, currentLanguage } = state;
+  const {
+    conversations,
+    currentConversationId,
+    sidebarOpen,
+    availableLanguages,
+    currentLanguage,
+  } = state;
 
   // Helper to get flag for a language code
   const getFlag = (languageCode: string): string => {
@@ -25,7 +31,9 @@ export function Sidebar() {
   const inputRef = useRef<HTMLInputElement>(null);
   const langMenuRef = useRef<HTMLDivElement>(null);
 
-  const currentLang = availableLanguages.find(l => l.code === currentLanguage);
+  const currentLang = availableLanguages.find(
+    (l) => l.code === currentLanguage
+  );
 
   // Focus input when editing starts
   useEffect(() => {
@@ -38,7 +46,10 @@ export function Sidebar() {
   // Close language menu when clicking outside
   useEffect(() => {
     function handleClickOutside(event: MouseEvent) {
-      if (langMenuRef.current && !langMenuRef.current.contains(event.target as Node)) {
+      if (
+        langMenuRef.current &&
+        !langMenuRef.current.contains(event.target as Node)
+      ) {
         setShowLangMenu(false);
       }
     }
@@ -198,8 +209,12 @@ export function Sidebar() {
                         className="conversation-button"
                         onClick={() => selectConversation(conversation.id)}
                       >
-                        <span className="conversation-flag-left">{getFlag(conversation.languageCode)}</span>
-                        <span className="conversation-title">{conversation.title}</span>
+                        <span className="conversation-flag-left">
+                          {getFlag(conversation.languageCode)}
+                        </span>
+                        <span className="conversation-title">
+                          {conversation.title}
+                        </span>
                       </button>
                       <div className="conversation-actions">
                         <button
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 45bcc56..7a373d1 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -171,18 +171,27 @@ function appReducer(state: AppState, action: AppAction): AppState {
     case 'SET_SIDEBAR_OPEN':
       return { ...state, sidebarOpen: action.payload };
     case 'ADD_CONVERSATION':
-      return { ...state, conversations: [action.payload, ...state.conversations] };
+      return {
+        ...state,
+        conversations: [action.payload, ...state.conversations],
+      };
     case 'REMOVE_CONVERSATION':
       return {
         ...state,
-        conversations: state.conversations.filter((c) => c.id !== action.payload),
+        conversations: state.conversations.filter(
+          (c) => c.id !== action.payload
+        ),
       };
     case 'RENAME_CONVERSATION':
       return {
         ...state,
         conversations: state.conversations.map((c) =>
           c.id === action.payload.id
-            ? { ...c, title: action.payload.title, updatedAt: new Date().toISOString() }
+            ? {
+                ...c,
+                title: action.payload.title,
+                updatedAt: new Date().toISOString(),
+              }
             : c
         ),
       };
@@ -247,32 +256,57 @@ export function AppProvider({ children }: AppProviderProps) {
       // Sync data on login
       if (!hasMigratedRef.current) {
         hasMigratedRef.current = true;
-        const languages = stateRef.current.availableLanguages.map((l) => l.code);
-        const langsToSync = languages.length > 0 ? languages : [stateRef.current.currentLanguage];
+        const languages = stateRef.current.availableLanguages.map(
+          (l) => l.code
+        );
+        const langsToSync =
+          languages.length > 0 ? languages : [stateRef.current.currentLanguage];
 
-        // First try to sync FROM Supabase (existing user on new device)
+        // First try to sync ALL conversations FROM Supabase (existing user on new device)
         // Then migrate any local data TO Supabase
-        storage.syncFromSupabase(langsToSync).then(({ conversations }) => {
-          // If user has conversations in Supabase, reload the UI state
-          const currentLang = stateRef.current.currentLanguage;
-          const remoteConvos = conversations.get(currentLang);
-          if (remoteConvos && remoteConvos.length > 0) {
-            dispatch({ type: 'SET_CONVERSATIONS', payload: remoteConvos });
-            // Load the most recent conversation
-            const mostRecent = remoteConvos[0];
-            dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: mostRecent.id });
-            const convData = storage.getConversation(mostRecent.id);
-            if (convData) {
-              const chatHistory = convData.messages.map((m) => ({
-                role: m.role === 'user' ? 'learner' : 'teacher',
-                content: m.content,
-              })) as ChatMessage[];
-              dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+        storage
+          .syncAllConversationsFromSupabase()
+          .then((allConversations) => {
+            // If user has conversations in Supabase, reload the UI state with ALL of them
+            if (allConversations.length > 0) {
+              dispatch({
+                type: 'SET_CONVERSATIONS',
+                payload: allConversations,
+              });
+              // Load the most recent conversation
+              const mostRecent = allConversations[0];
+              dispatch({
+                type: 'SET_CURRENT_CONVERSATION_ID',
+                payload: mostRecent.id,
+              });
+              // Update language to match the most recent conversation
+              if (
+                mostRecent.languageCode !== stateRef.current.currentLanguage
+              ) {
+                dispatch({
+                  type: 'SET_LANGUAGE',
+                  payload: mostRecent.languageCode,
+                });
+                storage.saveLanguage(mostRecent.languageCode);
+              }
+              const convData = storage.getConversation(mostRecent.id);
+              if (convData) {
+                const chatHistory = convData.messages.map((m) => ({
+                  role: m.role === 'user' ? 'learner' : 'teacher',
+                  content: m.content,
+                })) as ChatMessage[];
+                dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+              }
+              // Load flashcards for the most recent conversation
+              const flashcards = storage.getFlashcardsForConversation(
+                mostRecent.id
+              );
+              dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
             }
-          }
-          // Also migrate any local data that isn't in Supabase yet
-          return storage.migrateToSupabase(langsToSync);
-        }).catch(console.error);
+            // Also migrate any local data that isn't in Supabase yet
+            return storage.migrateToSupabase(langsToSync);
+          })
+          .catch(console.error);
       }
     } else {
       storage.clearSupabaseClient();
@@ -292,7 +326,9 @@ export function AppProvider({ children }: AppProviderProps) {
   // Refs for callbacks to avoid effect dependency issues
   const handleInterruptRef = useRef<() => void>(() => {});
   const checkAndUpdateConversationRef = useRef<() => void>(() => {});
-  const processPendingFlashcardsRef = useRef<(conversationId: string) => void>(() => {});
+  const processPendingFlashcardsRef = useRef<(conversationId: string) => void>(
+    () => {}
+  );
 
   // Initialize audio player
   useEffect(() => {
@@ -317,7 +353,10 @@ export function AppProvider({ children }: AppProviderProps) {
       // Update language to match the most recent conversation
       const mostRecentConvo = allConversations[0];
       if (mostRecentConvo.languageCode !== state.currentLanguage) {
-        dispatch({ type: 'SET_LANGUAGE', payload: mostRecentConvo.languageCode });
+        dispatch({
+          type: 'SET_LANGUAGE',
+          payload: mostRecentConvo.languageCode,
+        });
         storage.saveLanguage(mostRecentConvo.languageCode);
       }
       storage.setCurrentConversationId(mostRecentConvo.languageCode, currentId);
@@ -410,17 +449,27 @@ export function AppProvider({ children }: AppProviderProps) {
 
     // Auto-create conversation if none exists and we're about to add messages
     if (!conversationId && (pendingTranscription || pendingLLMResponse)) {
-      const newConversation = storage.createConversation(currentState.currentLanguage);
+      const newConversation = storage.createConversation(
+        currentState.currentLanguage
+      );
       conversationId = newConversation.id;
       conversationTitle = newConversation.title;
       dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
-      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
-      storage.setCurrentConversationId(currentState.currentLanguage, newConversation.id);
+      dispatch({
+        type: 'SET_CURRENT_CONVERSATION_ID',
+        payload: newConversation.id,
+      });
+      storage.setCurrentConversationId(
+        currentState.currentLanguage,
+        newConversation.id
+      );
       // Process any flashcards that arrived before conversation was created
       processPendingFlashcardsRef.current(newConversation.id);
     } else if (conversationId) {
       // Get title from existing conversation in state
-      const currentConvo = currentState.conversations.find((c) => c.id === conversationId);
+      const currentConvo = currentState.conversations.find(
+        (c) => c.id === conversationId
+      );
       conversationTitle = currentConvo?.title || null;
     }
 
@@ -499,10 +548,24 @@ export function AppProvider({ children }: AppProviderProps) {
 
       if (teacherAlreadyAdded && !userAlreadyAdded) {
         // Auto-rename conversation on first user message (if still has default name)
-        if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
-          const newTitle = pendingTranscription.length > 10 ? pendingTranscription.slice(0, 10) + '...' : pendingTranscription;
-          storage.renameConversation(conversationId, newTitle, currentState.currentLanguage);
-          dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+        if (
+          conversationId &&
+          conversationTitle &&
+          /^Chat \d{5}$/.test(conversationTitle)
+        ) {
+          const newTitle =
+            pendingTranscription.length > 10
+              ? pendingTranscription.slice(0, 10) + '...'
+              : pendingTranscription;
+          storage.renameConversation(
+            conversationId,
+            newTitle,
+            currentState.currentLanguage
+          );
+          dispatch({
+            type: 'RENAME_CONVERSATION',
+            payload: { id: conversationId, title: newTitle },
+          });
         }
 
         storage.addMessage('user', pendingTranscription);
@@ -526,10 +589,24 @@ export function AppProvider({ children }: AppProviderProps) {
       // Add user message only if not already added
       if (!userAlreadyAdded) {
         // Auto-rename conversation on first user message (if still has default name)
-        if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
-          const newTitle = pendingTranscription.length > 10 ? pendingTranscription.slice(0, 10) + '...' : pendingTranscription;
-          storage.renameConversation(conversationId, newTitle, currentState.currentLanguage);
-          dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+        if (
+          conversationId &&
+          conversationTitle &&
+          /^Chat \d{5}$/.test(conversationTitle)
+        ) {
+          const newTitle =
+            pendingTranscription.length > 10
+              ? pendingTranscription.slice(0, 10) + '...'
+              : pendingTranscription;
+          storage.renameConversation(
+            conversationId,
+            newTitle,
+            currentState.currentLanguage
+          );
+          dispatch({
+            type: 'RENAME_CONVERSATION',
+            payload: { id: conversationId, title: newTitle },
+          });
         }
 
         storage.addMessage('user', pendingTranscription);
@@ -566,7 +643,9 @@ export function AppProvider({ children }: AppProviderProps) {
     const pending = pendingFlashcardsRef.current;
 
     if (pending.length > 0) {
-      console.log(`[AppContext] Processing ${pending.length} pending flashcards for conversation ${conversationId}`);
+      console.log(
+        `[AppContext] Processing ${pending.length} pending flashcards for conversation ${conversationId}`
+      );
       const updatedFlashcards = storage.addFlashcardsForConversation(
         conversationId,
         pending,
@@ -580,6 +659,17 @@ export function AppProvider({ children }: AppProviderProps) {
   // Keep ref updated
   processPendingFlashcardsRef.current = processPendingFlashcards;
 
+  // Process pending flashcards when conversation ID becomes available
+  // This handles the race condition where flashcards arrive before the conversation is created
+  useEffect(() => {
+    if (
+      state.currentConversationId &&
+      pendingFlashcardsRef.current.length > 0
+    ) {
+      processPendingFlashcards(state.currentConversationId);
+    }
+  }, [state.currentConversationId, processPendingFlashcards]);
+
   // Handle interrupt
   const handleInterrupt = useCallback(() => {
     console.log('[AppContext] Handling interrupt');
@@ -812,8 +902,13 @@ export function AppProvider({ children }: AppProviderProps) {
         dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
       } else {
         // No conversation yet - queue flashcards for later processing
-        console.log(`[AppContext] Queuing ${cards.length} flashcards (no conversation yet)`);
-        pendingFlashcardsRef.current = [...pendingFlashcardsRef.current, ...cards];
+        console.log(
+          `[AppContext] Queuing ${cards.length} flashcards (no conversation yet)`
+        );
+        pendingFlashcardsRef.current = [
+          ...pendingFlashcardsRef.current,
+          ...cards,
+        ];
       }
     });
 
@@ -930,25 +1025,49 @@ export function AppProvider({ children }: AppProviderProps) {
 
       // Auto-create conversation if none exists
       if (!conversationId) {
-        const newConversation = storage.createConversation(stateRef.current.currentLanguage);
+        const newConversation = storage.createConversation(
+          stateRef.current.currentLanguage
+        );
         conversationId = newConversation.id;
         conversationTitle = newConversation.title;
         dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
-        dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
-        storage.setCurrentConversationId(stateRef.current.currentLanguage, newConversation.id);
+        dispatch({
+          type: 'SET_CURRENT_CONVERSATION_ID',
+          payload: newConversation.id,
+        });
+        storage.setCurrentConversationId(
+          stateRef.current.currentLanguage,
+          newConversation.id
+        );
         // Process any flashcards that arrived before conversation was created
         processPendingFlashcardsRef.current(newConversation.id);
       } else {
         // Get title from existing conversation in state
-        const currentConvo = stateRef.current.conversations.find((c) => c.id === conversationId);
+        const currentConvo = stateRef.current.conversations.find(
+          (c) => c.id === conversationId
+        );
         conversationTitle = currentConvo?.title || null;
       }
 
       // Auto-rename conversation on first user message (if still has default name)
-      if (conversationId && conversationTitle && /^Chat \d{5}$/.test(conversationTitle)) {
-        const newTitle = trimmedText.length > 10 ? trimmedText.slice(0, 10) + '...' : trimmedText;
-        storage.renameConversation(conversationId, newTitle, stateRef.current.currentLanguage);
-        dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: newTitle } });
+      if (
+        conversationId &&
+        conversationTitle &&
+        /^Chat \d{5}$/.test(conversationTitle)
+      ) {
+        const newTitle =
+          trimmedText.length > 10
+            ? trimmedText.slice(0, 10) + '...'
+            : trimmedText;
+        storage.renameConversation(
+          conversationId,
+          newTitle,
+          stateRef.current.currentLanguage
+        );
+        dispatch({
+          type: 'RENAME_CONVERSATION',
+          payload: { id: conversationId, title: newTitle },
+        });
       }
 
       // Add user message to chat history immediately (unlike audio where we wait for transcription)
@@ -984,18 +1103,28 @@ export function AppProvider({ children }: AppProviderProps) {
       audioPlayer.stop();
 
       // Save current conversation first if it exists
-      if (state.currentConversationId && stateRef.current.chatHistory.length > 0) {
+      if (
+        state.currentConversationId &&
+        stateRef.current.chatHistory.length > 0
+      ) {
         const messages = stateRef.current.chatHistory.map((m) => ({
           role: m.role === 'learner' ? 'user' : 'assistant',
           content: m.content,
           timestamp: new Date().toISOString(),
         })) as import('../types').ConversationMessage[];
-        storage.saveConversation(state.currentConversationId, messages, state.currentLanguage);
+        storage.saveConversation(
+          state.currentConversationId,
+          messages,
+          state.currentLanguage
+        );
       }
 
       // Find the conversation to get its language
-      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
-      const targetLanguage = conversation?.languageCode || state.currentLanguage;
+      const conversation = stateRef.current.conversations.find(
+        (c) => c.id === conversationId
+      );
+      const targetLanguage =
+        conversation?.languageCode || state.currentLanguage;
 
       // Switch language if different
       if (targetLanguage !== state.currentLanguage) {
@@ -1018,7 +1147,10 @@ export function AppProvider({ children }: AppProviderProps) {
         dispatch({ type: 'SET_CHAT_HISTORY', payload: [] });
       }
 
-      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: conversationId });
+      dispatch({
+        type: 'SET_CURRENT_CONVERSATION_ID',
+        payload: conversationId,
+      });
       storage.setCurrentConversationId(targetLanguage, conversationId);
 
       // Load flashcards for this specific conversation
@@ -1046,7 +1178,12 @@ export function AppProvider({ children }: AppProviderProps) {
       // Close sidebar on mobile
       dispatch({ type: 'SET_SIDEBAR_OPEN', payload: false });
     },
-    [state.isRecording, state.currentConversationId, state.currentLanguage, state.connectionStatus]
+    [
+      state.isRecording,
+      state.currentConversationId,
+      state.currentLanguage,
+      state.connectionStatus,
+    ]
   );
 
   // Create a new conversation
@@ -1064,19 +1201,29 @@ export function AppProvider({ children }: AppProviderProps) {
     audioPlayer.stop();
 
     // Save current conversation first if it exists
-    if (state.currentConversationId && stateRef.current.chatHistory.length > 0) {
+    if (
+      state.currentConversationId &&
+      stateRef.current.chatHistory.length > 0
+    ) {
       const messages = stateRef.current.chatHistory.map((m) => ({
         role: m.role === 'learner' ? 'user' : 'assistant',
         content: m.content,
         timestamp: new Date().toISOString(),
       })) as import('../types').ConversationMessage[];
-      storage.saveConversation(state.currentConversationId, messages, state.currentLanguage);
+      storage.saveConversation(
+        state.currentConversationId,
+        messages,
+        state.currentLanguage
+      );
     }
 
     // Create new conversation
     const newConversation = storage.createConversation(state.currentLanguage);
     dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
-    dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: newConversation.id });
+    dispatch({
+      type: 'SET_CURRENT_CONVERSATION_ID',
+      payload: newConversation.id,
+    });
     storage.setCurrentConversationId(state.currentLanguage, newConversation.id);
 
     // Clear chat and flashcards (new conversation has no flashcards)
@@ -1094,7 +1241,12 @@ export function AppProvider({ children }: AppProviderProps) {
 
     // Close sidebar on mobile
     dispatch({ type: 'SET_SIDEBAR_OPEN', payload: false });
-  }, [state.isRecording, state.currentConversationId, state.currentLanguage, state.connectionStatus]);
+  }, [
+    state.isRecording,
+    state.currentConversationId,
+    state.currentLanguage,
+    state.connectionStatus,
+  ]);
 
   // Delete a conversation
   const deleteConversation = useCallback(
@@ -1102,7 +1254,9 @@ export function AppProvider({ children }: AppProviderProps) {
       const storage = storageRef.current;
 
       // Find the conversation to get its language code
-      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
+      const conversation = stateRef.current.conversations.find(
+        (c) => c.id === conversationId
+      );
       const languageCode = conversation?.languageCode || state.currentLanguage;
 
       storage.deleteConversation(conversationId, languageCode);
@@ -1122,7 +1276,12 @@ export function AppProvider({ children }: AppProviderProps) {
         }
       }
     },
-    [state.currentLanguage, state.currentConversationId, selectConversation, createNewConversation]
+    [
+      state.currentLanguage,
+      state.currentConversationId,
+      selectConversation,
+      createNewConversation,
+    ]
   );
 
   // Rename a conversation
@@ -1133,18 +1292,26 @@ export function AppProvider({ children }: AppProviderProps) {
       if (!trimmedTitle) return;
 
       // Find the conversation to get its language code
-      const conversation = stateRef.current.conversations.find((c) => c.id === conversationId);
+      const conversation = stateRef.current.conversations.find(
+        (c) => c.id === conversationId
+      );
       const languageCode = conversation?.languageCode || state.currentLanguage;
 
       storage.renameConversation(conversationId, trimmedTitle, languageCode);
-      dispatch({ type: 'RENAME_CONVERSATION', payload: { id: conversationId, title: trimmedTitle } });
+      dispatch({
+        type: 'RENAME_CONVERSATION',
+        payload: { id: conversationId, title: trimmedTitle },
+      });
     },
     [state.currentLanguage]
   );
 
   // Toggle sidebar
   const toggleSidebar = useCallback(() => {
-    dispatch({ type: 'SET_SIDEBAR_OPEN', payload: !stateRef.current.sidebarOpen });
+    dispatch({
+      type: 'SET_SIDEBAR_OPEN',
+      payload: !stateRef.current.sidebarOpen,
+    });
   }, []);
 
   const value: AppContextType = {
diff --git a/frontend/src/context/AuthContext.tsx b/frontend/src/context/AuthContext.tsx
index ff59cb9..44a4756 100644
--- a/frontend/src/context/AuthContext.tsx
+++ b/frontend/src/context/AuthContext.tsx
@@ -14,8 +14,14 @@ interface AuthContextType {
   session: Session | null;
   isLoading: boolean;
   isConfigured: boolean;
-  signUp: (email: string, password: string) => Promise<{ error: string | null }>;
-  signIn: (email: string, password: string) => Promise<{ error: string | null }>;
+  signUp: (
+    email: string,
+    password: string
+  ) => Promise<{ error: string | null }>;
+  signIn: (
+    email: string,
+    password: string
+  ) => Promise<{ error: string | null }>;
   signOut: () => Promise<void>;
 }
 
@@ -64,7 +70,10 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     return () => subscription.unsubscribe();
   }, [supabase]);
 
-  const signUp = async (email: string, password: string): Promise<{ error: string | null }> => {
+  const signUp = async (
+    email: string,
+    password: string
+  ): Promise<{ error: string | null }> => {
     if (!supabase) return { error: 'Supabase not configured' };
 
     const { error } = await supabase.auth.signUp({
@@ -75,7 +84,10 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     return { error: error?.message ?? null };
   };
 
-  const signIn = async (email: string, password: string): Promise<{ error: string | null }> => {
+  const signIn = async (
+    email: string,
+    password: string
+  ): Promise<{ error: string | null }> => {
     if (!supabase) return { error: 'Supabase not configured' };
 
     const { error } = await supabase.auth.signInWithPassword({
diff --git a/frontend/src/services/HybridStorage.ts b/frontend/src/services/HybridStorage.ts
index 8d66328..e33091d 100644
--- a/frontend/src/services/HybridStorage.ts
+++ b/frontend/src/services/HybridStorage.ts
@@ -50,17 +50,31 @@ export class HybridStorage extends Storage {
     return summary;
   }
 
-  override deleteConversation(conversationId: string, languageCode: string): void {
+  override deleteConversation(
+    conversationId: string,
+    languageCode: string
+  ): void {
     super.deleteConversation(conversationId, languageCode);
-    this.supabaseStorage?.deleteConversation(conversationId).catch(console.error);
+    this.supabaseStorage
+      ?.deleteConversation(conversationId)
+      .catch(console.error);
   }
 
-  override renameConversation(conversationId: string, newTitle: string, languageCode: string): void {
+  override renameConversation(
+    conversationId: string,
+    newTitle: string,
+    languageCode: string
+  ): void {
     super.renameConversation(conversationId, newTitle, languageCode);
-    this.supabaseStorage?.renameConversation(conversationId, newTitle).catch(console.error);
+    this.supabaseStorage
+      ?.renameConversation(conversationId, newTitle)
+      .catch(console.error);
   }
 
-  override addFlashcards(newFlashcards: Flashcard[], languageCode: string): Flashcard[] {
+  override addFlashcards(
+    newFlashcards: Flashcard[],
+    languageCode: string
+  ): Flashcard[] {
     const result = super.addFlashcards(newFlashcards, languageCode);
     this.supabaseStorage
       ?.addFlashcards(newFlashcards, languageCode)
@@ -79,16 +93,26 @@ export class HybridStorage extends Storage {
     newFlashcards: Flashcard[],
     languageCode: string
   ): Flashcard[] {
-    const result = super.addFlashcardsForConversation(conversationId, newFlashcards, languageCode);
+    const result = super.addFlashcardsForConversation(
+      conversationId,
+      newFlashcards,
+      languageCode
+    );
     this.supabaseStorage
-      ?.addFlashcardsForConversation(conversationId, newFlashcards, languageCode)
+      ?.addFlashcardsForConversation(
+        conversationId,
+        newFlashcards,
+        languageCode
+      )
       .catch(console.error);
     return result;
   }
 
   override clearFlashcardsForConversation(conversationId: string): void {
     super.clearFlashcardsForConversation(conversationId);
-    this.supabaseStorage?.clearFlashcardsForConversation(conversationId).catch(console.error);
+    this.supabaseStorage
+      ?.clearFlashcardsForConversation(conversationId)
+      .catch(console.error);
   }
 
   // Migration: upload localStorage data to Supabase
@@ -165,7 +189,9 @@ export class HybridStorage extends Storage {
 
         // Merge: remote conversations + local conversations not in remote
         const remoteIds = new Set(remoteConversations.map((c) => c.id));
-        const localOnly = localConversations.filter((c) => !remoteIds.has(c.id));
+        const localOnly = localConversations.filter(
+          (c) => !remoteIds.has(c.id)
+        );
         const merged = [...remoteConversations, ...localOnly];
 
         // Sort by updatedAt descending
@@ -233,4 +259,91 @@ export class HybridStorage extends Storage {
     return { conversations, flashcards };
   }
 
+  // Sync ALL conversations from Supabase (regardless of language)
+  // Returns a flat list merged with local conversations
+  async syncAllConversationsFromSupabase(): Promise<ConversationSummary[]> {
+    if (!this.supabaseStorage) {
+      return super.getAllConversations();
+    }
+
+    try {
+      // Get all remote conversations (no language filter)
+      const remoteConversations =
+        await this.supabaseStorage.getAllConversations();
+      const localConversations = super.getAllConversations();
+
+      // Merge: remote conversations + local conversations not in remote
+      const remoteIds = new Set(remoteConversations.map((c) => c.id));
+      const localOnly = localConversations.filter((c) => !remoteIds.has(c.id));
+      const merged = [...remoteConversations, ...localOnly];
+
+      // Sort by updatedAt descending
+      merged.sort(
+        (a, b) =>
+          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+
+      // Save merged conversations to localStorage (grouped by language)
+      const byLanguage = new Map<string, ConversationSummary[]>();
+      for (const conv of merged) {
+        const lang = conv.languageCode;
+        if (!byLanguage.has(lang)) {
+          byLanguage.set(lang, []);
+        }
+        byLanguage.get(lang)!.push(conv);
+      }
+      for (const [lang, convos] of byLanguage) {
+        localStorage.setItem(
+          `aprende-conversations-${lang}`,
+          JSON.stringify(convos)
+        );
+      }
+
+      // Load remote conversation messages and flashcards to localStorage
+      for (const conv of remoteConversations) {
+        const data = await this.supabaseStorage.getConversation(conv.id);
+        if (data) {
+          localStorage.setItem(
+            `aprende-conversation-${conv.id}`,
+            JSON.stringify(data)
+          );
+        }
+
+        // Also sync flashcards for this conversation
+        const remoteFlashcards =
+          await this.supabaseStorage.getFlashcardsForConversation(conv.id);
+        if (remoteFlashcards.length > 0) {
+          // Merge with any local flashcards (remote takes priority)
+          const localFlashcards = super.getFlashcardsForConversation(conv.id);
+          const seenWords = new Set<string>();
+          const mergedFlashcards: Flashcard[] = [];
+
+          // Remote flashcards take priority
+          for (const f of remoteFlashcards) {
+            const word = (f.targetWord || '').toLowerCase();
+            if (!seenWords.has(word)) {
+              seenWords.add(word);
+              mergedFlashcards.push(f);
+            }
+          }
+          // Add local flashcards not in remote
+          for (const f of localFlashcards) {
+            const word = (f.targetWord || '').toLowerCase();
+            if (!seenWords.has(word)) {
+              seenWords.add(word);
+              mergedFlashcards.push(f);
+            }
+          }
+
+          super.saveFlashcardsForConversation(conv.id, mergedFlashcards);
+        }
+      }
+
+      console.log(`Synced ${merged.length} conversations from Supabase`);
+      return merged;
+    } catch (e) {
+      console.error('Failed to sync all conversations from Supabase:', e);
+      return super.getAllConversations();
+    }
+  }
 }
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index 875e4dc..ae3056d 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -155,7 +155,9 @@ export class Storage {
     }
   }
 
-  private migrateToMultiConversation(languageCode: string): ConversationSummary[] {
+  private migrateToMultiConversation(
+    languageCode: string
+  ): ConversationSummary[] {
     // Check if there's legacy conversation data
     const legacyData = localStorage.getItem(this.conversationKey);
     const currentLanguage = this.getLanguage();
@@ -220,7 +222,11 @@ export class Storage {
     }
   }
 
-  saveConversation(conversationId: string, messages: ConversationMessage[], languageCode: string): void {
+  saveConversation(
+    conversationId: string,
+    messages: ConversationMessage[],
+    languageCode: string
+  ): void {
     try {
       const conversationData: ConversationData = {
         id: conversationId,
@@ -297,14 +303,20 @@ export class Storage {
       // If this was the current conversation, clear current
       const currentId = this.getCurrentConversationId(languageCode);
       if (currentId === conversationId) {
-        localStorage.removeItem(this.currentConversationKeyPrefix + languageCode);
+        localStorage.removeItem(
+          this.currentConversationKeyPrefix + languageCode
+        );
       }
     } catch (error) {
       console.error('Failed to delete conversation:', error);
     }
   }
 
-  renameConversation(conversationId: string, newTitle: string, languageCode: string): void {
+  renameConversation(
+    conversationId: string,
+    newTitle: string,
+    languageCode: string
+  ): void {
     try {
       const list = this.getConversationList(languageCode);
       const index = list.findIndex((c) => c.id === conversationId);
@@ -323,7 +335,9 @@ export class Storage {
 
   getCurrentConversationId(languageCode: string): string | null {
     try {
-      return localStorage.getItem(this.currentConversationKeyPrefix + languageCode);
+      return localStorage.getItem(
+        this.currentConversationKeyPrefix + languageCode
+      );
     } catch {
       return null;
     }
@@ -355,8 +369,9 @@ export class Storage {
         }
       }
       // Sort by updatedAt descending (most recent first)
-      allConversations.sort((a, b) =>
-        new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      allConversations.sort(
+        (a, b) =>
+          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
       );
       return allConversations;
     } catch (error) {
@@ -466,7 +481,10 @@ export class Storage {
     }
   }
 
-  saveFlashcardsForConversation(conversationId: string, flashcards: Flashcard[]): void {
+  saveFlashcardsForConversation(
+    conversationId: string,
+    flashcards: Flashcard[]
+  ): void {
     try {
       const key = this.flashcardsConversationKeyPrefix + conversationId;
       localStorage.setItem(key, JSON.stringify(flashcards));
@@ -480,7 +498,8 @@ export class Storage {
     newFlashcards: Flashcard[],
     languageCode: string
   ): Flashcard[] {
-    const existingFlashcards = this.getFlashcardsForConversation(conversationId);
+    const existingFlashcards =
+      this.getFlashcardsForConversation(conversationId);
 
     // Filter out duplicates
     const uniqueNewFlashcards = newFlashcards.filter((newCard) => {
diff --git a/frontend/src/services/SupabaseStorage.ts b/frontend/src/services/SupabaseStorage.ts
index 71e0a73..29959bd 100644
--- a/frontend/src/services/SupabaseStorage.ts
+++ b/frontend/src/services/SupabaseStorage.ts
@@ -39,7 +39,9 @@ export class SupabaseStorage {
 
   // Conversations
 
-  async getConversationList(languageCode: string): Promise<ConversationSummary[]> {
+  async getConversationList(
+    languageCode: string
+  ): Promise<ConversationSummary[]> {
     const { data } = await this.supabase
       .from('conversations')
       .select('id, title, language_code, created_at, updated_at')
@@ -56,7 +58,25 @@ export class SupabaseStorage {
     }));
   }
 
-  async getConversation(conversationId: string): Promise<ConversationData | null> {
+  async getAllConversations(): Promise<ConversationSummary[]> {
+    const { data } = await this.supabase
+      .from('conversations')
+      .select('id, title, language_code, created_at, updated_at')
+      .eq('user_id', this.userId)
+      .order('updated_at', { ascending: false });
+
+    return (data ?? []).map((c) => ({
+      id: c.id,
+      title: c.title,
+      languageCode: c.language_code,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at,
+    }));
+  }
+
+  async getConversation(
+    conversationId: string
+  ): Promise<ConversationData | null> {
     const { data: messages } = await this.supabase
       .from('conversation_messages')
       .select('role, content, created_at')
@@ -165,7 +185,10 @@ export class SupabaseStorage {
     await this.supabase.from('conversations').delete().eq('id', conversationId);
   }
 
-  async renameConversation(conversationId: string, newTitle: string): Promise<void> {
+  async renameConversation(
+    conversationId: string,
+    newTitle: string
+  ): Promise<void> {
     await this.supabase
       .from('conversations')
       .update({ title: newTitle, updated_at: new Date().toISOString() })
@@ -221,7 +244,9 @@ export class SupabaseStorage {
   }
 
   // Per-conversation flashcard methods
-  async getFlashcardsForConversation(conversationId: string): Promise<Flashcard[]> {
+  async getFlashcardsForConversation(
+    conversationId: string
+  ): Promise<Flashcard[]> {
     const { data } = await this.supabase
       .from('flashcards')
       .select('*')
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
index a9b5a59..5bc40ce 100644
--- a/frontend/tsconfig.app.json
+++ b/frontend/tsconfig.app.json
@@ -24,5 +24,12 @@
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": [
+    "src/__tests__",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx"
+  ]
 }
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
new file mode 100644
index 0000000..ba33b2d
--- /dev/null
+++ b/tsconfig.eslint.json
@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["backend/**/*"],
+  "exclude": ["node_modules", "dist", "frontend", "templates/**"]
+}

From fdf7d31ddd2f33ce302cb6d213b9c41967b3295e Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Mon, 5 Jan 2026 11:57:21 -0800
Subject: [PATCH 25/49] added button to pronounce flashcard word

---
 README.md                                     |   2 +-
 backend/config/server.ts                      |   2 +-
 backend/graphs/simple-tts-graph.ts            | 100 ++++++++++++++++
 backend/services/websocket-handler.ts         | 107 ++++++++++++++++++
 frontend/src/components/Flashcard.tsx         |  40 ++++++-
 frontend/src/components/FlashcardsSection.tsx |  34 ++++--
 frontend/src/context/AppContext.tsx           |  58 +++++++++-
 frontend/src/services/WebSocketClient.ts      |  19 ++++
 frontend/src/styles/main.css                  |  69 ++++++++++-
 frontend/src/types/index.ts                   |   1 +
 10 files changed, 417 insertions(+), 15 deletions(-)
 create mode 100644 backend/graphs/simple-tts-graph.ts

diff --git a/README.md b/README.md
index 4cc8475..3572ed7 100644
--- a/README.md
+++ b/README.md
@@ -139,7 +139,7 @@ The app uses a real-time audio streaming architecture:
 | `PORT`                  | No       | Server port (default: 3000)                                        |
 | `LOG_LEVEL`             | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
 | `NODE_ENV`              | No       | `development` or `production`                                      |
-| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: medium)          |
+| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: high)          |
 
 ## Testing
 
diff --git a/backend/config/server.ts b/backend/config/server.ts
index 6ab5513..aa6f9ac 100644
--- a/backend/config/server.ts
+++ b/backend/config/server.ts
@@ -81,7 +81,7 @@ export const serverConfig = {
   assemblyAI: {
     /** Turn detection eagerness level */
     eagerness: (process.env.ASSEMBLY_AI_EAGERNESS ||
-      'medium') as AssemblyAIEagerness,
+      'high') as AssemblyAIEagerness,
     /** Format turns in output (typically false for real-time processing) */
     formatTurns: false,
   },
diff --git a/backend/graphs/simple-tts-graph.ts b/backend/graphs/simple-tts-graph.ts
new file mode 100644
index 0000000..eaf2240
--- /dev/null
+++ b/backend/graphs/simple-tts-graph.ts
@@ -0,0 +1,100 @@
+/**
+ * Simple TTS Graph
+ *
+ * A lightweight graph that takes text and produces TTS audio.
+ * Used for pronouncing individual words (e.g., flashcard pronunciation).
+ *
+ * Graph Flow:
+ * Input { text } → TextExtractor → RemoteTTS → Audio Output
+ *
+ * RemoteTTSNode accepts String directly as input, so we just need to
+ * extract the text from our input object.
+ */
+
+import {
+  Graph,
+  GraphBuilder,
+  CustomNode,
+  ProcessContext,
+  RemoteTTSNode,
+} from '@inworld/runtime/graph';
+import { getLanguageConfig } from '../config/languages.js';
+import { serverConfig } from '../config/server.js';
+import { graphLogger as logger } from '../utils/logger.js';
+
+export interface SimpleTTSInput {
+  text: string;
+}
+
+/**
+ * Simple node that extracts text string from input object
+ */
+class TextExtractorNode extends CustomNode {
+  process(_context: ProcessContext, input: SimpleTTSInput): string {
+    logger.info({ text: input.text }, 'simple_tts_extracting_text');
+    return input.text;
+  }
+}
+
+/**
+ * Creates a simple TTS graph for pronouncing words
+ * RemoteTTSNode accepts String directly as input
+ */
+function createSimpleTTSGraph(languageCode: string): Graph {
+  const langConfig = getLanguageConfig(languageCode);
+
+  logger.info(
+    {
+      languageCode,
+      speakerId: langConfig.ttsConfig.speakerId,
+      modelId: langConfig.ttsConfig.modelId,
+    },
+    'creating_simple_tts_graph_with_config'
+  );
+
+  const textExtractorNode = new TextExtractorNode({
+    id: 'simple-tts-text-extractor',
+  });
+
+  // RemoteTTSNode accepts String directly as input
+  const ttsNode = new RemoteTTSNode({
+    id: 'simple-tts-node',
+    speakerId: langConfig.ttsConfig.speakerId,
+    modelId: langConfig.ttsConfig.modelId,
+    sampleRate: serverConfig.audio.ttsSampleRate,
+    temperature: langConfig.ttsConfig.temperature,
+    speakingRate: langConfig.ttsConfig.speakingRate,
+    languageCode: langConfig.ttsConfig.languageCode,
+    reportToClient: true,
+  });
+
+  const graphBuilder = new GraphBuilder({
+    id: `simple-tts-graph-${languageCode}`,
+    enableRemoteConfig: false,
+  });
+
+  graphBuilder
+    .addNode(textExtractorNode)
+    .addNode(ttsNode)
+    .addEdge(textExtractorNode, ttsNode)
+    .setStartNode(textExtractorNode)
+    .setEndNode(ttsNode);
+
+  return graphBuilder.build();
+}
+
+// Cache for simple TTS graphs per language
+const simpleTTSGraphs: Map<string, Graph> = new Map();
+
+/**
+ * Get or create a simple TTS graph for a language
+ */
+export function getSimpleTTSGraph(languageCode: string): Graph {
+  let graph = simpleTTSGraphs.get(languageCode);
+  if (!graph) {
+    logger.info({ languageCode }, 'creating_simple_tts_graph');
+    graph = createSimpleTTSGraph(languageCode);
+    simpleTTSGraphs.set(languageCode, graph);
+  }
+  return graph;
+}
diff --git a/backend/services/websocket-handler.ts b/backend/services/websocket-handler.ts
index 1b94df5..cb7a578 100644
--- a/backend/services/websocket-handler.ts
+++ b/backend/services/websocket-handler.ts
@@ -6,6 +6,7 @@
 
 import { WebSocketServer, WebSocket } from 'ws';
 import { telemetry } from '@inworld/runtime';
+import { GraphTypes } from '@inworld/runtime/graph';
 
 import { ConnectionManager } from '../helpers/connection-manager.js';
 import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
@@ -16,6 +17,8 @@ import {
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
 import { serverLogger as logger } from '../utils/logger.js';
+import { getSimpleTTSGraph } from '../graphs/simple-tts-graph.js';
+import { serverConfig } from '../config/server.js';
 
 import {
   connections,
@@ -233,6 +236,8 @@ function handleMessage(
       handleFlashcardClicked(connectionId, message);
     } else if (message.type === 'text_message') {
       handleTextMessage(connectionId, ws, connectionManager, message);
+    } else if (message.type === 'tts_pronounce_request') {
+      handleTTSPronounce(connectionId, ws, message);
     } else {
       logger.debug(
         { connectionId, messageType: message.type },
@@ -385,3 +390,105 @@ function handleTextMessage(
   }
   connectionManager.sendTextMessage(text.trim());
 }
+
+/**
+ * Convert audio data to base64 string for WebSocket transmission
+ * Inworld TTS returns Float32 PCM in [-1.0, 1.0] range
+ */
+function convertAudioToBase64(audio: {
+  data?: string | number[] | Float32Array;
+  sampleRate?: number;
+}): { base64: string; format: 'float32' | 'int16' } | null {
+  if (!audio.data) return null;
+
+  if (typeof audio.data === 'string') {
+    // Already base64 - assume Int16 format for backwards compatibility
+    return { base64: audio.data, format: 'int16' };
+  }
+
+  // Inworld SDK returns audio.data as an array of raw bytes (0-255)
+  // These bytes ARE the Float32 PCM data in IEEE 754 format (4 bytes per sample)
+  const audioBuffer = Array.isArray(audio.data)
+    ? Buffer.from(audio.data)
+    : Buffer.from(
+        audio.data.buffer,
+        audio.data.byteOffset,
+        audio.data.byteLength
+      );
+
+  return {
+    base64: audioBuffer.toString('base64'),
+    format: 'float32',
+  };
+}
+
+async function handleTTSPronounce(
+  connectionId: string,
+  ws: WebSocket,
+  message: { text?: string; languageCode?: string }
+): Promise<void> {
+  const text = message.text;
+  const languageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
+
+  if (typeof text !== 'string' || text.trim().length === 0) {
+    ws.send(
+      JSON.stringify({ type: 'tts_pronounce_error', error: 'Empty text' })
+    );
+    return;
+  }
+
+  if (text.length > 100) {
+    logger.warn(
+      { connectionId, length: text.length },
+      'tts_pronounce_text_too_long'
+    );
+    ws.send(
+      JSON.stringify({ type: 'tts_pronounce_error', error: 'Text too long' })
+    );
+    return;
+  }
+
+  try {
+    const graph = getSimpleTTSGraph(languageCode);
+    const executionResult = await graph.start({ text: text.trim() });
+
+    for await (const res of executionResult.outputStream) {
+      if ('processResponse' in res) {
+        const resultWithProcess = res as {
+          processResponse: (
+            handlers: Record<string, (data: unknown) => Promise<void> | void>
+          ) => Promise<void>;
+        };
+        await resultWithProcess.processResponse({
+          TTSOutputStream: async (ttsData: unknown) => {
+            const ttsStream = ttsData as GraphTypes.TTSOutputStream;
+            for await (const chunk of ttsStream) {
+              if (chunk.audio?.data) {
+                const audioResult = convertAudioToBase64(chunk.audio);
+                if (audioResult) {
+                  ws.send(
+                    JSON.stringify({
+                      type: 'tts_pronounce_audio',
+                      audio: audioResult.base64,
+                      audioFormat: audioResult.format,
+                      sampleRate:
+                        chunk.audio.sampleRate ||
+                        serverConfig.audio.ttsSampleRate,
+                    })
+                  );
+                }
+              }
+            }
+          },
+        });
+      }
+    }
+
+    ws.send(JSON.stringify({ type: 'tts_pronounce_complete' }));
+  } catch (error) {
+    logger.error({ err: error, connectionId }, 'tts_pronounce_error');
+    ws.send(
+      JSON.stringify({ type: 'tts_pronounce_error', error: 'TTS failed' })
+    );
+  }
+}
diff --git a/frontend/src/components/Flashcard.tsx b/frontend/src/components/Flashcard.tsx
index 83888ee..ab81bc3 100644
--- a/frontend/src/components/Flashcard.tsx
+++ b/frontend/src/components/Flashcard.tsx
@@ -4,6 +4,8 @@ import type { Flashcard as FlashcardType } from '../types';
 interface FlashcardProps {
   flashcard: FlashcardType;
   onCardClick?: (flashcard: FlashcardType) => void;
+  onPronounce?: (flashcard: FlashcardType) => void;
+  isPronouncing?: boolean;
 }
 
 function escapeHtml(text: string): string {
@@ -12,7 +14,12 @@ function escapeHtml(text: string): string {
   return div.innerHTML;
 }
 
-export function Flashcard({ flashcard, onCardClick }: FlashcardProps) {
+export function Flashcard({
+  flashcard,
+  onCardClick,
+  onPronounce,
+  isPronouncing = false,
+}: FlashcardProps) {
   const [isFlipped, setIsFlipped] = useState(false);
 
   const handleClick = useCallback(() => {
@@ -20,6 +27,14 @@ export function Flashcard({ flashcard, onCardClick }: FlashcardProps) {
     onCardClick?.(flashcard);
   }, [flashcard, onCardClick]);
 
+  const handlePronounce = useCallback(
+    (e: React.MouseEvent) => {
+      e.stopPropagation();
+      onPronounce?.(flashcard);
+    },
+    [flashcard, onPronounce]
+  );
+
   // Support both new 'targetWord' and legacy 'spanish' field
   const targetWord =
     flashcard.targetWord || flashcard.spanish || flashcard.word || '';
@@ -38,6 +53,29 @@ export function Flashcard({ flashcard, onCardClick }: FlashcardProps) {
             className="flashcard-target-word"
             dangerouslySetInnerHTML={{ __html: escapeHtml(targetWord) }}
           />
+          <button
+            className={`pronounce-button ${isPronouncing ? 'loading' : ''}`}
+            onClick={handlePronounce}
+            disabled={isPronouncing}
+            aria-label="Pronounce word"
+          >
+            {isPronouncing ? (
+              <svg
+                className="pronounce-spinner"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="2"
+              >
+                <circle cx="12" cy="12" r="10" strokeOpacity="0.25" />
+                <path d="M12 2a10 10 0 0 1 10 10" strokeLinecap="round" />
+              </svg>
+            ) : (
+              <svg viewBox="0 0 24 24" fill="currentColor">
+                <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z" />
+              </svg>
+            )}
+          </button>
         </div>
         <div className="flashcard-back">
           <div
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
index 6a0be2b..ca063e0 100644
--- a/frontend/src/components/FlashcardsSection.tsx
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -10,8 +10,8 @@ const getApiUrl = (path: string): string => {
 };
 
 export function FlashcardsSection() {
-  const { state, wsClient } = useApp();
-  const { flashcards, currentLanguage } = state;
+  const { state, wsClient, pronounceWord } = useApp();
+  const { flashcards, currentLanguage, pronouncingCardId } = state;
   const [isExporting, setIsExporting] = useState(false);
 
   const handleCardClick = useCallback(
@@ -21,6 +21,16 @@ export function FlashcardsSection() {
     [wsClient]
   );
 
+  const handlePronounce = useCallback(
+    (card: FlashcardType) => {
+      const targetWord = card.targetWord || card.spanish || card.word || '';
+      if (!targetWord) return;
+
+      pronounceWord(targetWord);
+    },
+    [pronounceWord]
+  );
+
   const exportToAnki = useCallback(async () => {
     const validFlashcards = flashcards.filter((flashcard) => {
       const targetWord = flashcard.targetWord || flashcard.spanish;
@@ -116,13 +126,19 @@ export function FlashcardsSection() {
           {sortedFlashcards.length === 0 ? (
             <div className="empty-state"></div>
           ) : (
-            sortedFlashcards.map((flashcard, index) => (
-              <Flashcard
-                key={`card-${flashcard.targetWord || flashcard.spanish || index}`}
-                flashcard={flashcard}
-                onCardClick={handleCardClick}
-              />
-            ))
+            sortedFlashcards.map((flashcard, index) => {
+              const cardId =
+                flashcard.targetWord || flashcard.spanish || flashcard.word || '';
+              return (
+                <Flashcard
+                  key={`card-${cardId || index}`}
+                  flashcard={flashcard}
+                  onCardClick={handleCardClick}
+                  onPronounce={handlePronounce}
+                  isPronouncing={pronouncingCardId === cardId}
+                />
+              );
+            })
           )}
         </div>
       </div>
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 7a373d1..7d9778d 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -58,6 +58,7 @@ type AppAction =
   | { type: 'SET_SPEECH_DETECTED'; payload: boolean }
   | { type: 'SET_FLASHCARDS'; payload: Flashcard[] }
   | { type: 'ADD_FLASHCARDS'; payload: Flashcard[] }
+  | { type: 'SET_PRONOUNCING_CARD_ID'; payload: string | null }
   | {
       type: 'SET_FEEDBACK';
       payload: { messageContent: string; feedback: string };
@@ -85,6 +86,7 @@ const createInitialState = (storage: HybridStorage): AppState => ({
   isRecording: false,
   speechDetected: false,
   flashcards: [],
+  pronouncingCardId: null,
   feedbackMap: {},
   userId: storage.getOrCreateUserId(),
   conversations: [],
@@ -138,6 +140,8 @@ function appReducer(state: AppState, action: AppAction): AppState {
       );
       return { ...state, flashcards: [...state.flashcards, ...newCards] };
     }
+    case 'SET_PRONOUNCING_CARD_ID':
+      return { ...state, pronouncingCardId: action.payload };
     case 'SET_FEEDBACK':
       return {
         ...state,
@@ -213,6 +217,7 @@ interface AppContextType {
   changeLanguage: (newLanguage: string) => void;
   handleInterrupt: () => void;
   sendTextMessage: (text: string) => void;
+  pronounceWord: (text: string) => void;
   // Conversation actions
   selectConversation: (conversationId: string) => void;
   createNewConversation: () => void;
@@ -234,6 +239,7 @@ export function AppProvider({ children }: AppProviderProps) {
   const wsClientRef = useRef(new WebSocketClient(getWebSocketUrl()));
   const audioHandlerRef = useRef(new AudioHandler());
   const audioPlayerRef = useRef(new AudioPlayer());
+  const ttsAudioPlayerRef = useRef(new AudioPlayer());
   const hasMigratedRef = useRef(false);
 
   const [state, dispatch] = useReducer(
@@ -330,11 +336,13 @@ export function AppProvider({ children }: AppProviderProps) {
     () => {}
   );
 
-  // Initialize audio player
+  // Initialize audio players
   useEffect(() => {
     audioPlayerRef.current.initialize().catch(console.error);
+    ttsAudioPlayerRef.current.initialize().catch(console.error);
     return () => {
       audioPlayerRef.current.destroy();
+      ttsAudioPlayerRef.current.destroy();
     };
   }, []);
 
@@ -840,6 +848,30 @@ export function AppProvider({ children }: AppProviderProps) {
       audioPlayer.markStreamComplete();
     });
 
+    // TTS pronunciation handlers (for flashcard pronunciation)
+    const ttsAudioPlayer = ttsAudioPlayerRef.current;
+    wsClient.on('tts_pronounce_audio', (data) => {
+      const audioData = data as {
+        audio: string;
+        audioFormat: string;
+        sampleRate: number;
+      };
+      ttsAudioPlayer.addAudioStream(
+        audioData.audio,
+        audioData.sampleRate,
+        false,
+        audioData.audioFormat as 'int16' | 'float32'
+      );
+    });
+
+    wsClient.on('tts_pronounce_complete', () => {
+      dispatch({ type: 'SET_PRONOUNCING_CARD_ID', payload: null });
+    });
+
+    wsClient.on('tts_pronounce_error', () => {
+      dispatch({ type: 'SET_PRONOUNCING_CARD_ID', payload: null });
+    });
+
     wsClient.on('interrupt', (data) => {
       const reason = (data as { reason?: string })?.reason;
 
@@ -1087,6 +1119,29 @@ export function AppProvider({ children }: AppProviderProps) {
     [state.connectionStatus]
   );
 
+  // Pronounce a word using TTS (for flashcard pronunciation)
+  const pronounceWord = useCallback(
+    (text: string) => {
+      const wsClient = wsClientRef.current;
+      const ttsAudioPlayer = ttsAudioPlayerRef.current;
+      const trimmedText = text.trim();
+
+      if (state.connectionStatus !== 'connected' || !trimmedText) return;
+
+      // Stop any currently playing TTS audio
+      ttsAudioPlayer.stop();
+
+      // Use the text itself as the card ID for tracking
+      dispatch({ type: 'SET_PRONOUNCING_CARD_ID', payload: trimmedText });
+      wsClient.send({
+        type: 'tts_pronounce_request',
+        text: trimmedText,
+        languageCode: state.currentLanguage,
+      });
+    },
+    [state.connectionStatus, state.currentLanguage]
+  );
+
   // Select a conversation from the sidebar
   const selectConversation = useCallback(
     (conversationId: string) => {
@@ -1325,6 +1380,7 @@ export function AppProvider({ children }: AppProviderProps) {
     changeLanguage,
     handleInterrupt,
     sendTextMessage,
+    pronounceWord,
     selectConversation,
     createNewConversation,
     deleteConversation,
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index 13d18d9..b243f0b 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -62,6 +62,7 @@ export class WebSocketClient {
 
   private emit(event: string, data?: unknown): void {
     const callbacks = this.listeners.get(event);
+    console.log(`[WebSocketClient] emit('${event}'), listeners:`, callbacks?.length ?? 0);
     if (callbacks) {
       callbacks.forEach((callback) => callback(data));
     }
@@ -299,6 +300,24 @@ export class WebSocketClient {
         });
         break;
 
+      case 'tts_pronounce_audio':
+        this.emit('tts_pronounce_audio', {
+          audio: message.audio,
+          audioFormat: message.audioFormat || 'float32',
+          sampleRate: message.sampleRate,
+        });
+        break;
+
+      case 'tts_pronounce_complete':
+        this.emit('tts_pronounce_complete', {});
+        break;
+
+      case 'tts_pronounce_error':
+        this.emit('tts_pronounce_error', {
+          error: message.error,
+        });
+        break;
+
       default:
         console.log('Unknown message type:', message.type);
     }
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 9c28268..bc5bc66 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -528,6 +528,7 @@ body {
     color: #1a1a1a;
     text-align: left;
     transition: background-color 0.15s ease;
+    width: 100%;
 }
 
 .dropdown-button:hover {
@@ -1026,7 +1027,6 @@ body {
     display: flex;
     gap: 8px;
     padding-top: 16px;
-    border-top: 1px solid #e5e5e5;
     margin-top: 16px;
 }
 
@@ -1161,6 +1161,59 @@ body {
     color: #1a1a1a;
 }
 
+/* Pronounce button on flashcard */
+.pronounce-button {
+    position: absolute;
+    bottom: 12px;
+    right: 12px;
+    width: 36px;
+    height: 36px;
+    border-radius: 50%;
+    border: 2px solid #d1d5db;
+    background: #ffffff;
+    color: #6b7280;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s ease;
+    z-index: 10;
+    padding: 0;
+}
+
+.pronounce-button:hover:not(:disabled) {
+    border-color: #1a1a1a;
+    color: #1a1a1a;
+    transform: scale(1.08);
+}
+
+.pronounce-button:disabled {
+    opacity: 0.7;
+    cursor: not-allowed;
+}
+
+.pronounce-button.loading {
+    border-color: #6b7280;
+}
+
+.pronounce-button svg {
+    width: 18px;
+    height: 18px;
+}
+
+.pronounce-spinner {
+    animation: spin-pronounce 1s linear infinite;
+}
+
+@keyframes spin-pronounce {
+    from {
+        transform: rotate(0deg);
+    }
+    to {
+        transform: rotate(360deg);
+    }
+}
+
 .flashcard-back {
     background: #ffffff;
     border: 2px solid #e5e5e5;
@@ -1249,6 +1302,18 @@ body {
     .flashcard-back {
         padding: 16px;
     }
+
+    .pronounce-button {
+        width: 32px;
+        height: 32px;
+        bottom: 8px;
+        right: 8px;
+    }
+
+    .pronounce-button svg {
+        width: 16px;
+        height: 16px;
+    }
 }
 
 .empty-state {
@@ -1552,5 +1617,5 @@ body {
 }
 
 .message.learner:hover {
-    background: #c8e6d5;
+    background: #333333;
 }
\ No newline at end of file
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 1a9e0df..9008cc1 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -147,6 +147,7 @@ export interface AppState {
 
   // Flashcards
   flashcards: Flashcard[];
+  pronouncingCardId: string | null;
 
   // Feedback (keyed by user message content)
   feedbackMap: Record<string, string>;

From f2a8a60d0ed21a4c6ef646ff09f6174c328118cf Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Mon, 5 Jan 2026 12:05:01 -0800
Subject: [PATCH 26/49] linter fixes

---
 README.md                                     | 2 +-
 frontend/src/components/FlashcardsSection.tsx | 5 ++++-
 frontend/src/services/WebSocketClient.ts      | 5 ++++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 3572ed7..5d66733 100644
--- a/README.md
+++ b/README.md
@@ -139,7 +139,7 @@ The app uses a real-time audio streaming architecture:
 | `PORT`                  | No       | Server port (default: 3000)                                        |
 | `LOG_LEVEL`             | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
 | `NODE_ENV`              | No       | `development` or `production`                                      |
-| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: high)          |
+| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: high)            |
 
 ## Testing
 
diff --git a/frontend/src/components/FlashcardsSection.tsx b/frontend/src/components/FlashcardsSection.tsx
index ca063e0..e7c5145 100644
--- a/frontend/src/components/FlashcardsSection.tsx
+++ b/frontend/src/components/FlashcardsSection.tsx
@@ -128,7 +128,10 @@ export function FlashcardsSection() {
           ) : (
             sortedFlashcards.map((flashcard, index) => {
               const cardId =
-                flashcard.targetWord || flashcard.spanish || flashcard.word || '';
+                flashcard.targetWord ||
+                flashcard.spanish ||
+                flashcard.word ||
+                '';
               return (
                 <Flashcard
                   key={`card-${cardId || index}`}
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index b243f0b..b7d4be4 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -62,7 +62,10 @@ export class WebSocketClient {
 
   private emit(event: string, data?: unknown): void {
     const callbacks = this.listeners.get(event);
-    console.log(`[WebSocketClient] emit('${event}'), listeners:`, callbacks?.length ?? 0);
+    console.log(
+      `[WebSocketClient] emit('${event}'), listeners:`,
+      callbacks?.length ?? 0
+    );
     if (callbacks) {
       callbacks.forEach((callback) => callback(data));
     }

From 9f1ce1adeb9ee0d5519491311482e0cf49da1695 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Mon, 5 Jan 2026 12:10:09 -0800
Subject: [PATCH 27/49] linter fixes

---
 backend/graphs/configs/flashcard-generation-graph.json | 10 +++-------
 .../configs/lang-learning-conversation-graph.json      | 10 +++-------
 backend/graphs/configs/response-feedback-graph.json    | 10 +++-------
 3 files changed, 9 insertions(+), 21 deletions(-)

diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/graphs/configs/flashcard-generation-graph.json
index 7cb5d7b..a73589e 100644
--- a/backend/graphs/configs/flashcard-generation-graph.json
+++ b/backend/graphs/configs/flashcard-generation-graph.json
@@ -70,12 +70,8 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": [
-      "flashcard-parser"
-    ],
-    "start_nodes": [
-      "flashcard-prompt-builder"
-    ]
+    "end_nodes": ["flashcard-parser"],
+    "start_nodes": ["flashcard-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
index 78379bb..b22afa6 100644
--- a/backend/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -219,12 +219,8 @@
         "loop": true
       }
     ],
-    "end_nodes": [
-      "tts-node-lang-learning"
-    ],
-    "start_nodes": [
-      "audio-input-proxy-lang-learning"
-    ]
+    "end_nodes": ["tts-node-lang-learning"],
+    "start_nodes": ["audio-input-proxy-lang-learning"]
   },
   "components": [
     {
@@ -276,4 +272,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/graphs/configs/response-feedback-graph.json
index 978b019..d694a2b 100644
--- a/backend/graphs/configs/response-feedback-graph.json
+++ b/backend/graphs/configs/response-feedback-graph.json
@@ -70,12 +70,8 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": [
-      "feedback-extractor"
-    ],
-    "start_nodes": [
-      "feedback-prompt-builder"
-    ]
+    "end_nodes": ["feedback-extractor"],
+    "start_nodes": ["feedback-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}

From 65454efc0454658074aed8fefe4ee9af57d82bf3 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 6 Jan 2026 17:04:48 -0800
Subject: [PATCH 28/49] Added storing and retrieving of memory embeddings -
 needs polish

---
 README.md                                     |  27 +-
 backend/config/embedder.ts                    |  12 +
 backend/config/llm.ts                         |  19 ++
 backend/config/supabase.ts                    |  43 +++
 .../configs/flashcard-generation-graph.json   |  10 +-
 .../lang-learning-conversation-graph.json     |  24 +-
 .../configs/response-feedback-graph.json      |  10 +-
 backend/graphs/conversation-graph.ts          |  13 +-
 backend/graphs/memory-generation-graph.ts     |  74 +++++
 .../nodes/dialog-prompt-builder-node.ts       |  10 +-
 .../nodes/memory-prompt-builder-node.ts       |  56 ++++
 backend/graphs/nodes/memory-retrieval-node.ts | 152 +++++++++
 backend/helpers/connection-manager.ts         |  64 +++-
 backend/helpers/memory-processor.ts           | 291 ++++++++++++++++++
 backend/prompts/conversation.njk              |   7 +
 backend/prompts/memory-generation.njk         |  30 ++
 backend/services/memory-service.ts            | 248 +++++++++++++++
 backend/services/state.ts                     |   2 +
 backend/services/websocket-handler.ts         |  40 +++
 backend/types/index.ts                        |   2 +
 backend/types/memory.ts                       |  76 +++++
 package-lock.json                             | 103 ++++++-
 package.json                                  |   1 +
 ...1_schema.sql => 20250102000000_schema.sql} |   0
 .../migrations/20250106000000_memories.sql    |  88 ++++++
 25 files changed, 1375 insertions(+), 27 deletions(-)
 create mode 100644 backend/config/embedder.ts
 create mode 100644 backend/config/supabase.ts
 create mode 100644 backend/graphs/memory-generation-graph.ts
 create mode 100644 backend/graphs/nodes/memory-prompt-builder-node.ts
 create mode 100644 backend/graphs/nodes/memory-retrieval-node.ts
 create mode 100644 backend/helpers/memory-processor.ts
 create mode 100644 backend/prompts/memory-generation.njk
 create mode 100644 backend/services/memory-service.ts
 create mode 100644 backend/types/memory.ts
 rename supabase/migrations/{00001_schema.sql => 20250102000000_schema.sql} (100%)
 create mode 100644 supabase/migrations/20250106000000_memories.sql

diff --git a/README.md b/README.md
index 5d66733..f7a6762 100644
--- a/README.md
+++ b/README.md
@@ -78,7 +78,14 @@ npx supabase db push
 
 Find your project ref in the Supabase dashboard URL: `supabase.com/dashboard/project/YOUR_PROJECT_REF`
 
-**c) Create `frontend/.env.local`:**
+**c) Add Supabase variables to `.env` (root):**
+
+```bash
+SUPABASE_URL=https://YOUR_PROJECT.supabase.co
+SUPABASE_SERVICE_ROLE_KEY=your_service_role_key
+```
+
+**d) Create `frontend/.env.local`:**
 
 ```bash
 VITE_SUPABASE_URL=https://YOUR_PROJECT.supabase.co
@@ -132,14 +139,16 @@ The app uses a real-time audio streaming architecture:
 
 ## Environment Variables Reference
 
-| Variable                | Required | Description                                                        |
-| ----------------------- | -------- | ------------------------------------------------------------------ |
-| `INWORLD_API_KEY`       | Yes      | Inworld AI Base64 API key                                          |
-| `ASSEMBLY_AI_API_KEY`   | Yes      | AssemblyAI API key                                                 |
-| `PORT`                  | No       | Server port (default: 3000)                                        |
-| `LOG_LEVEL`             | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
-| `NODE_ENV`              | No       | `development` or `production`                                      |
-| `ASSEMBLY_AI_EAGERNESS` | No       | Turn detection: `low`, `medium`, `high` (default: high)            |
+| Variable                     | Required | Description                                                        |
+| ---------------------------- | -------- | ------------------------------------------------------------------ |
+| `INWORLD_API_KEY`            | Yes      | Inworld AI Base64 API key                                          |
+| `ASSEMBLY_AI_API_KEY`        | Yes      | AssemblyAI API key                                                 |
+| `PORT`                       | No       | Server port (default: 3000)                                        |
+| `LOG_LEVEL`                  | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
+| `NODE_ENV`                   | No       | `development` or `production`                                      |
+| `ASSEMBLY_AI_EAGERNESS`      | No       | Turn detection: `low`, `medium`, `high` (default: high)            |
+| `SUPABASE_URL`               | No       | Supabase project URL (enables memory feature)                      |
+| `SUPABASE_SERVICE_ROLE_KEY`  | No       | Supabase service role key (for backend memory storage)             |
 
 ## Testing
 
diff --git a/backend/config/embedder.ts b/backend/config/embedder.ts
new file mode 100644
index 0000000..91b8aae
--- /dev/null
+++ b/backend/config/embedder.ts
@@ -0,0 +1,12 @@
+/**
+ * Embedder Configuration
+ *
+ * Uses Inworld's remote embedder with BAAI/bge-large-en-v1.5 model.
+ * This model produces 1024-dimensional embeddings.
+ */
+
+export const embedderConfig = {
+  provider: 'inworld' as const,
+  modelName: 'BAAI/bge-large-en-v1.5',
+  dimensions: 1024,
+};
diff --git a/backend/config/llm.ts b/backend/config/llm.ts
index 66fbb83..615830a 100644
--- a/backend/config/llm.ts
+++ b/backend/config/llm.ts
@@ -79,4 +79,23 @@ export const llmConfig = {
       presencePenalty: 0,
     },
   } satisfies LLMNodeConfig,
+
+  /**
+   * Memory generation LLM - creates memories from conversation context
+   * Non-streaming, moderate temperature for varied but accurate memories
+   */
+  memoryGeneration: {
+    provider: 'openai',
+    model: 'gpt-4.1-nano',
+    stream: false,
+    textGenerationConfig: {
+      maxNewTokens: 200,
+      maxPromptLength: 2000,
+      temperature: 0.7,
+      topP: 1,
+      repetitionPenalty: 1,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    },
+  } satisfies LLMNodeConfig,
 } as const;
diff --git a/backend/config/supabase.ts b/backend/config/supabase.ts
new file mode 100644
index 0000000..2ca8d5f
--- /dev/null
+++ b/backend/config/supabase.ts
@@ -0,0 +1,43 @@
+/**
+ * Supabase Backend Client Configuration
+ *
+ * Sets up Supabase client for server-side operations (memories, embeddings).
+ * Uses service role key for admin access (bypasses RLS).
+ */
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+
+let supabaseClient: SupabaseClient | null = null;
+
+/**
+ * Get or create the Supabase client singleton.
+ * Returns null if environment variables are not configured.
+ */
+export function getSupabaseClient(): SupabaseClient | null {
+  if (supabaseClient) {
+    return supabaseClient;
+  }
+
+  const supabaseUrl = process.env.SUPABASE_URL;
+  const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!supabaseUrl || !supabaseServiceKey) {
+    // Supabase not configured - memory features will be disabled
+    return null;
+  }
+
+  supabaseClient = createClient(supabaseUrl, supabaseServiceKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  });
+
+  return supabaseClient;
+}
+
+/**
+ * Check if Supabase is configured and available.
+ */
+export function isSupabaseConfigured(): boolean {
+  return !!(process.env.SUPABASE_URL && process.env.SUPABASE_SERVICE_ROLE_KEY);
+}
diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/graphs/configs/flashcard-generation-graph.json
index a73589e..7cb5d7b 100644
--- a/backend/graphs/configs/flashcard-generation-graph.json
+++ b/backend/graphs/configs/flashcard-generation-graph.json
@@ -70,8 +70,12 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": ["flashcard-parser"],
-    "start_nodes": ["flashcard-prompt-builder"]
+    "end_nodes": [
+      "flashcard-parser"
+    ],
+    "start_nodes": [
+      "flashcard-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
index b22afa6..4c34e49 100644
--- a/backend/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -53,6 +53,16 @@
           }
         }
       },
+      {
+        "type": "MemoryRetrievalNodeType",
+        "id": "memory-retrieval-node-lang-learning",
+        "execution_config": {
+          "type": "NodeExecutionConfig",
+          "properties": {
+            "report_to_client": false
+          }
+        }
+      },
       {
         "type": "DialogPromptBuilderNodeType",
         "id": "dialog-prompt-builder-node-lang-learning",
@@ -182,6 +192,10 @@
       },
       {
         "from_node": "text-input-node-lang-learning",
+        "to_node": "memory-retrieval-node-lang-learning"
+      },
+      {
+        "from_node": "memory-retrieval-node-lang-learning",
         "to_node": "dialog-prompt-builder-node-lang-learning"
       },
       {
@@ -219,8 +233,12 @@
         "loop": true
       }
     ],
-    "end_nodes": ["tts-node-lang-learning"],
-    "start_nodes": ["audio-input-proxy-lang-learning"]
+    "end_nodes": [
+      "tts-node-lang-learning"
+    ],
+    "start_nodes": [
+      "audio-input-proxy-lang-learning"
+    ]
   },
   "components": [
     {
@@ -272,4 +290,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/graphs/configs/response-feedback-graph.json
index d694a2b..978b019 100644
--- a/backend/graphs/configs/response-feedback-graph.json
+++ b/backend/graphs/configs/response-feedback-graph.json
@@ -70,8 +70,12 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": ["feedback-extractor"],
-    "start_nodes": ["feedback-prompt-builder"]
+    "end_nodes": [
+      "feedback-extractor"
+    ],
+    "start_nodes": [
+      "feedback-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 5e4a7c3..1a8b58a 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -26,6 +26,7 @@ import {
 import { AssemblyAISTTWebSocketNode } from './nodes/assembly-ai-stt-ws-node.js';
 import { DialogPromptBuilderNode } from './nodes/dialog-prompt-builder-node.js';
 import { InteractionQueueNode } from './nodes/interaction-queue-node.js';
+import { MemoryRetrievalNode } from './nodes/memory-retrieval-node.js';
 import { StateUpdateNode } from './nodes/state-update-node.js';
 import { TextInputNode } from './nodes/text-input-node.js';
 import { TranscriptExtractorNode } from './nodes/transcript-extractor-node.js';
@@ -124,6 +125,12 @@ export class ConversationGraphWrapper {
       reportToClient: true,
     });
 
+    const memoryRetrievalNode = new MemoryRetrievalNode({
+      id: `memory-retrieval-node${postfix}`,
+      connections,
+      reportToClient: false,
+    });
+
     const dialogPromptBuilderNode = new DialogPromptBuilderNode({
       id: `dialog-prompt-builder-node${postfix}`,
       connections,
@@ -187,6 +194,7 @@ export class ConversationGraphWrapper {
       .addNode(transcriptExtractorNode)
       .addNode(interactionQueueNode)
       .addNode(textInputNode)
+      .addNode(memoryRetrievalNode)
       .addNode(dialogPromptBuilderNode)
       .addNode(llmNode)
       .addNode(textChunkingNode)
@@ -232,8 +240,9 @@ export class ConversationGraphWrapper {
         },
       })
 
-      // TextInput updates state and passes to prompt builder
-      .addEdge(textInputNode, dialogPromptBuilderNode)
+      // TextInput updates state, retrieves memories, then builds prompt
+      .addEdge(textInputNode, memoryRetrievalNode)
+      .addEdge(memoryRetrievalNode, dialogPromptBuilderNode)
 
       // Also pass state to TTS builder for voice selection
       .addEdge(textInputNode, ttsRequestBuilderNode)
diff --git a/backend/graphs/memory-generation-graph.ts b/backend/graphs/memory-generation-graph.ts
new file mode 100644
index 0000000..eae75ae
--- /dev/null
+++ b/backend/graphs/memory-generation-graph.ts
@@ -0,0 +1,74 @@
+/**
+ * Memory Generation Graph
+ *
+ * A simple graph that generates memories from conversation history.
+ * Used by the MemoryProcessor to create memory records in the background.
+ *
+ * Graph Flow:
+ * Input → MemoryPromptBuilder → LLM → Output
+ */
+
+import {
+  Graph,
+  GraphBuilder,
+  ProxyNode,
+  RemoteLLMChatNode,
+} from '@inworld/runtime/graph';
+
+import { MemoryPromptBuilderNode } from './nodes/memory-prompt-builder-node.js';
+import { llmConfig } from '../config/llm.js';
+import { graphLogger as logger } from '../utils/logger.js';
+
+export interface MemoryGenerationGraphConfig {
+  graphId?: string;
+}
+
+/**
+ * Create a memory generation graph
+ */
+export function createMemoryGenerationGraph(
+  config: MemoryGenerationGraphConfig = {}
+): Graph {
+  const { graphId = 'memory-generation-graph' } = config;
+
+  logger.info({ graphId }, 'creating_memory_generation_graph');
+
+  // Input proxy node
+  const inputNode = new ProxyNode({ id: `${graphId}-input` });
+
+  // Memory prompt builder
+  const memoryPromptBuilderNode = new MemoryPromptBuilderNode({
+    id: `${graphId}-prompt-builder`,
+  });
+
+  // LLM node for memory generation
+  const llmNode = new RemoteLLMChatNode({
+    id: `${graphId}-llm`,
+    provider: llmConfig.memoryGeneration.provider,
+    modelName: llmConfig.memoryGeneration.model,
+    stream: false,
+    textGenerationConfig: llmConfig.memoryGeneration.textGenerationConfig,
+    reportToClient: false,
+  });
+
+  // Build the graph
+  const graphBuilder = new GraphBuilder({
+    id: graphId,
+    enableRemoteConfig: false,
+  });
+
+  graphBuilder
+    .addNode(inputNode)
+    .addNode(memoryPromptBuilderNode)
+    .addNode(llmNode)
+    .addEdge(inputNode, memoryPromptBuilderNode)
+    .addEdge(memoryPromptBuilderNode, llmNode)
+    .setStartNode(inputNode)
+    .setEndNode(llmNode);
+
+  const graph = graphBuilder.build();
+
+  logger.info({ graphId }, 'memory_generation_graph_created');
+
+  return graph;
+}
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index d1d9be4..6e8be53 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -11,10 +11,16 @@
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { ConnectionsMap, State } from '../../types/index.js';
+import { MemoryMatch } from '../../types/memory.js';
 import { getLanguageConfig } from '../../config/languages.js';
 import { conversationTemplate } from '../../helpers/prompt-templates.js';
 import { graphLogger as logger } from '../../utils/logger.js';
 
+// Extended state type that includes memories
+export interface StateWithMemories extends State {
+  relevantMemories?: MemoryMatch[];
+}
+
 export class DialogPromptBuilderNode extends CustomNode {
   constructor(props: {
     id: string;
@@ -30,12 +36,13 @@ export class DialogPromptBuilderNode extends CustomNode {
 
   async process(
     _context: ProcessContext,
-    state: State
+    state: StateWithMemories
   ): Promise<GraphTypes.LLMChatRequest> {
     logger.debug(
       {
         languageCode: state.languageCode || 'es',
         messageCount: state.messages?.length || 0,
+        memoryCount: state.relevantMemories?.length || 0,
       },
       'building_prompt'
     );
@@ -70,6 +77,7 @@ export class DialogPromptBuilderNode extends CustomNode {
         content: m.content,
       })),
       current_input: currentInput,
+      relevant_memories: state.relevantMemories || [],
       ...templateVars,
     };
 
diff --git a/backend/graphs/nodes/memory-prompt-builder-node.ts b/backend/graphs/nodes/memory-prompt-builder-node.ts
new file mode 100644
index 0000000..32b479e
--- /dev/null
+++ b/backend/graphs/nodes/memory-prompt-builder-node.ts
@@ -0,0 +1,56 @@
+/**
+ * MemoryPromptBuilderNode builds the prompt for memory generation.
+ *
+ * Takes conversation messages and target language, renders the memory
+ * generation template, and outputs an LLMChatRequest.
+ */
+
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { GraphTypes } from '@inworld/runtime/common';
+import { PromptBuilder } from '@inworld/runtime/primitives/llm';
+import { readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const promptsDir = join(__dirname, '..', '..', 'prompts');
+
+// Cache for the template
+let memoryGenerationTemplate: string | null = null;
+
+async function loadMemoryTemplate(): Promise<string> {
+  if (!memoryGenerationTemplate) {
+    memoryGenerationTemplate = await readFile(
+      join(promptsDir, 'memory-generation.njk'),
+      'utf-8'
+    );
+  }
+  return memoryGenerationTemplate;
+}
+
+export interface MemoryPromptInput {
+  messages: Array<{ role: string; content: string }>;
+  target_language: string;
+}
+
+export class MemoryPromptBuilderNode extends CustomNode {
+  constructor(props: { id: string }) {
+    super({ id: props.id });
+  }
+
+  async process(
+    _context: ProcessContext,
+    input: MemoryPromptInput
+  ): Promise<GraphTypes.LLMChatRequest> {
+    const template = await loadMemoryTemplate();
+    const builder = await PromptBuilder.create(template);
+    const renderedPrompt = await builder.build({
+      messages: input.messages,
+      target_language: input.target_language,
+    });
+    return new GraphTypes.LLMChatRequest({
+      messages: [{ role: 'user', content: renderedPrompt }],
+    });
+  }
+}
diff --git a/backend/graphs/nodes/memory-retrieval-node.ts b/backend/graphs/nodes/memory-retrieval-node.ts
new file mode 100644
index 0000000..931dd64
--- /dev/null
+++ b/backend/graphs/nodes/memory-retrieval-node.ts
@@ -0,0 +1,152 @@
+/**
+ * MemoryRetrievalNode retrieves relevant memories before prompt building.
+ *
+ * This node:
+ * - Receives the current state with user input
+ * - Embeds the user's current message
+ * - Queries Supabase for similar memories using vector similarity
+ * - Returns state enriched with relevant memories
+ */
+
+import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
+import { TextEmbedder } from '@inworld/runtime/primitives/embeddings';
+import { State, ConnectionsMap } from '../../types/index.js';
+import { MemoryMatch } from '../../types/memory.js';
+import { getMemoryService } from '../../services/memory-service.js';
+import { isSupabaseConfigured } from '../../config/supabase.js';
+import { embedderConfig } from '../../config/embedder.js';
+import { graphLogger as logger } from '../../utils/logger.js';
+
+/**
+ * Extended state with relevant memories
+ */
+export interface StateWithMemories extends State {
+  relevantMemories?: MemoryMatch[];
+}
+
+// Singleton embedder - shared across all MemoryRetrievalNode instances
+let sharedEmbedder: TextEmbedder | null = null;
+let sharedInitPromise: Promise<void> | null = null;
+
+/**
+ * Initialize shared embedder lazily
+ */
+async function initSharedEmbedder(): Promise<void> {
+  if (sharedEmbedder) {
+    return;
+  }
+
+  if (sharedInitPromise) {
+    return sharedInitPromise;
+  }
+
+  sharedInitPromise = (async () => {
+    try {
+      sharedEmbedder = await TextEmbedder.create({
+        remoteConfig: {
+          apiKey: process.env.INWORLD_API_KEY!,
+          provider: embedderConfig.provider,
+          modelName: embedderConfig.modelName,
+        },
+      });
+      logger.info('memory_retrieval_embedder_initialized');
+    } catch (error) {
+      logger.error({ err: error }, 'memory_retrieval_embedder_init_failed');
+      sharedInitPromise = null; // Allow retry
+      throw error;
+    }
+  })();
+
+  return sharedInitPromise;
+}
+
+export class MemoryRetrievalNode extends CustomNode {
+  constructor(props: {
+    id: string;
+    connections: ConnectionsMap;
+    reportToClient?: boolean;
+  }) {
+    super({
+      id: props.id,
+      reportToClient: props.reportToClient,
+    });
+    logger.info({ nodeId: props.id }, 'memory_retrieval_node_constructed');
+    // Note: embedder is initialized lazily on first use, not during construction
+  }
+
+  async process(
+    context: ProcessContext,
+    state: State
+  ): Promise<StateWithMemories> {
+    logger.info({ nodeId: this.id, hasState: !!state }, 'memory_retrieval_node_entered');
+
+    // Get user ID from state (flows through the graph from connection.state)
+    const userId = state.userId;
+    logger.info({ userId: userId?.substring(0, 8) }, 'memory_retrieval_got_userId');
+
+    // If no userId or Supabase not configured, skip memory retrieval
+    if (!userId || !isSupabaseConfigured()) {
+      logger.info(
+        { hasUserId: !!userId, supabaseConfigured: isSupabaseConfigured() },
+        'skipping_memory_retrieval'
+      );
+      return { ...state, relevantMemories: [] };
+    }
+
+    // Get the last user message for embedding
+    const lastUserMessage = [...state.messages]
+      .reverse()
+      .find((m) => m.role === 'user');
+
+    if (!lastUserMessage) {
+      return { ...state, relevantMemories: [] };
+    }
+
+    try {
+      logger.info(
+        { userId: userId.substring(0, 8), userMessage: lastUserMessage.content.substring(0, 50) },
+        'memory_retrieval_starting'
+      );
+
+      // Initialize embedder lazily (only when actually needed)
+      await initSharedEmbedder();
+
+      if (!sharedEmbedder) {
+        logger.warn('embedder_not_available');
+        return { ...state, relevantMemories: [] };
+      }
+
+      // Embed user message
+      logger.debug('embedding_user_message');
+      const embedResponse = await sharedEmbedder.embed(lastUserMessage.content);
+      const queryEmbedding = TextEmbedder.toArray(embedResponse);
+      logger.debug({ embeddingLength: queryEmbedding.length }, 'embedding_generated');
+
+      // Retrieve similar memories
+      const memoryService = getMemoryService();
+      const memories = await memoryService.retrieveMemories(
+        userId,
+        queryEmbedding,
+        3, // limit: up to 3 memories
+        0.5 // threshold: lowered from 0.65 for testing
+      );
+
+      logger.info(
+        {
+          memoriesFound: memories.length,
+          userId: userId.substring(0, 8),
+          memories: memories.map(m => ({ content: m.content.substring(0, 50), similarity: m.similarity }))
+        },
+        'memories_retrieved_for_prompt'
+      );
+
+      return {
+        ...state,
+        relevantMemories: memories,
+      };
+    } catch (error) {
+      logger.error({ err: error }, 'memory_retrieval_error');
+      return { ...state, relevantMemories: [] };
+    }
+  }
+}
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index a76a242..9d49f9d 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -48,6 +48,14 @@ export class ConnectionManager {
       ) => Promise<void>)
     | null = null;
 
+  // Callback for memory creation (non-blocking, fire-and-forget)
+  private memoryCallback:
+    | ((messages: Array<{ role: string; content: string }>) => void)
+    | null = null;
+
+  // User ID for memory retrieval/creation
+  private userId: string | undefined = undefined;
+
   // Processing state tracking for utterance stitching
   private isProcessingResponse: boolean = false;
   private currentTranscript: string = '';
@@ -140,12 +148,18 @@ export class ConnectionManager {
 
     this.logger.info('graph_execution_started');
 
+    // Build dataStoreContent - only include userId if defined
+    const dataStoreContent: Record<string, unknown> = {
+      sessionId: this.sessionId,
+      state: connection.state,
+    };
+    if (this.userId) {
+      dataStoreContent.userId = this.userId;
+    }
+
     const { outputStream } = await this.graphWrapper.graph.start(taggedStream, {
       executionId: this.sessionId,
-      dataStoreContent: {
-        sessionId: this.sessionId,
-        state: connection.state,
-      },
+      dataStoreContent,
       userContext: {
         attributes: {
           languageCode: this.languageCode,
@@ -350,9 +364,10 @@ export class ConnectionManager {
               timestamp: Date.now(),
             });
 
-            // Trigger flashcard and feedback generation after TTS completes
+            // Trigger flashcard, feedback, and memory generation after TTS completes
             this.triggerFlashcardGeneration();
             this.triggerFeedbackGeneration();
+            this.triggerMemoryGeneration();
           } else {
             this.logger.debug('tts_interrupted_skipping_completion');
           }
@@ -615,6 +630,25 @@ export class ConnectionManager {
     );
   }
 
+  /**
+   * Trigger memory generation (non-blocking, fire-and-forget)
+   * The callback handles turn counting and decides whether to create a memory
+   */
+  private triggerMemoryGeneration(): void {
+    if (!this.memoryCallback) return;
+
+    const connection = this.connections[this.sessionId];
+    if (!connection) return;
+
+    const recentMessages = connection.state.messages.slice(-10).map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    // Fire and forget - the callback is synchronous and handles async internally
+    this.memoryCallback(recentMessages);
+  }
+
   // ============================================================
   // Public API (compatible with AudioProcessor)
   // ============================================================
@@ -636,6 +670,26 @@ export class ConnectionManager {
     this.feedbackCallback = callback;
   }
 
+  setMemoryCallback(
+    callback: (messages: Array<{ role: string; content: string }>) => void
+  ): void {
+    this.memoryCallback = callback;
+  }
+
+  /**
+   * Set the user ID for memory retrieval and creation
+   * This should be called when user context is received
+   */
+  setUserId(userId: string): void {
+    this.userId = userId;
+    // Also update connection state so it flows through the graph
+    const connection = this.connections[this.sessionId];
+    if (connection) {
+      connection.state.userId = userId;
+    }
+    this.logger.info({ userId: userId.substring(0, 8) }, 'user_id_set');
+  }
+
   getConversationState(): {
     messages: Array<{ role: string; content: string; timestamp: string }>;
   } {
diff --git a/backend/helpers/memory-processor.ts b/backend/helpers/memory-processor.ts
new file mode 100644
index 0000000..73fdc59
--- /dev/null
+++ b/backend/helpers/memory-processor.ts
@@ -0,0 +1,291 @@
+/**
+ * Memory Processor
+ *
+ * Generates, embeds, and stores memories from conversations.
+ * Designed for non-blocking (fire-and-forget) execution.
+ *
+ * Features:
+ * - Turn counting to trigger memory creation every N turns
+ * - LLM-based memory generation from conversation context
+ * - Embedding generation using BAAI/bge-large-en-v1.5
+ * - Storage in Supabase with pgvector
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { Graph } from '@inworld/runtime/graph';
+import { TextEmbedder } from '@inworld/runtime/primitives/embeddings';
+import { getMemoryService } from '../services/memory-service.js';
+import { isSupabaseConfigured } from '../config/supabase.js';
+import { embedderConfig } from '../config/embedder.js';
+import { createMemoryGenerationGraph } from '../graphs/memory-generation-graph.js';
+import {
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../config/languages.js';
+import {
+  MemoryRecord,
+  MemoryType,
+  MemoryGenerationOutput,
+} from '../types/memory.js';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('MemoryProcessor');
+
+// Singleton graph instance - shared across all MemoryProcessor instances
+let sharedGraph: Graph | null = null;
+let sharedEmbedder: TextEmbedder | null = null;
+let sharedInitPromise: Promise<void> | null = null;
+
+/**
+ * Initialize shared resources (graph and embedder) - called lazily
+ */
+async function initSharedResources(): Promise<void> {
+  if (sharedGraph && sharedEmbedder) {
+    return;
+  }
+
+  if (sharedInitPromise) {
+    return sharedInitPromise;
+  }
+
+  sharedInitPromise = (async () => {
+    try {
+      // Initialize embedder
+      sharedEmbedder = await TextEmbedder.create({
+        remoteConfig: {
+          apiKey: process.env.INWORLD_API_KEY!,
+          provider: embedderConfig.provider,
+          modelName: embedderConfig.modelName,
+        },
+      });
+
+      // Initialize memory generation graph
+      sharedGraph = createMemoryGenerationGraph();
+
+      logger.info('memory_processor_initialized');
+    } catch (error) {
+      logger.error({ err: error }, 'memory_processor_init_failed');
+      sharedInitPromise = null; // Allow retry
+      throw error;
+    }
+  })();
+
+  return sharedInitPromise;
+}
+
+/**
+ * Memory Processor class for generating and storing user memories
+ */
+export class MemoryProcessor {
+  private turnCount: number = 0;
+  private readonly turnInterval: number = 3;
+  private languageCode: string = DEFAULT_LANGUAGE_CODE;
+
+  constructor(languageCode: string = DEFAULT_LANGUAGE_CODE) {
+    this.languageCode = languageCode;
+    logger.info('memory_processor_created');
+  }
+
+  /**
+   * Update the language for this processor
+   */
+  setLanguage(languageCode: string): void {
+    if (this.languageCode !== languageCode) {
+      this.languageCode = languageCode;
+      logger.debug({ languageCode }, 'memory_processor_language_changed');
+    }
+  }
+
+  /**
+   * Increment turn count - call after each completed turn
+   */
+  incrementTurn(): void {
+    this.turnCount++;
+    logger.debug({ turnCount: this.turnCount }, 'memory_turn_incremented');
+  }
+
+  /**
+   * Check if we should create a memory this turn
+   */
+  shouldCreateMemory(): boolean {
+    return this.turnCount > 0 && this.turnCount % this.turnInterval === 0;
+  }
+
+  /**
+   * Get current turn count
+   */
+  getTurnCount(): number {
+    return this.turnCount;
+  }
+
+  /**
+   * Non-blocking memory creation (fire-and-forget)
+   * Call this without awaiting to not block the conversation
+   */
+  createMemoryAsync(
+    userId: string,
+    messages: Array<{ role: string; content: string }>
+  ): void {
+    // Fire and forget - don't await in calling code
+    this.processMemoryCreation(userId, messages).catch((error) => {
+      logger.error({ err: error }, 'memory_creation_failed');
+    });
+  }
+
+  /**
+   * Internal method to process memory creation
+   */
+  private async processMemoryCreation(
+    userId: string,
+    messages: Array<{ role: string; content: string }>
+  ): Promise<void> {
+    if (!isSupabaseConfigured()) {
+      logger.debug('supabase_not_configured_skipping_memory_creation');
+      return;
+    }
+
+    // Initialize shared resources lazily (only when first memory is created)
+    await initSharedResources();
+
+    if (!sharedGraph || !sharedEmbedder) {
+      logger.warn('memory_processor_not_ready');
+      return;
+    }
+
+    try {
+      const langConfig = getLanguageConfig(this.languageCode);
+
+      // Step 1: Generate memory using LLM
+      const input = {
+        messages: messages.slice(-10), // Last 10 messages for context
+        target_language: langConfig.name,
+      };
+
+      const executionResult = await sharedGraph.start(input, {
+        executionId: uuidv4(),
+      });
+
+      let llmOutput: string = '';
+      for await (const res of executionResult.outputStream) {
+        if (res.data) {
+          // Extract content from LLM response
+          const data = res.data as { content?: string } | string;
+          llmOutput = typeof data === 'string' ? data : data.content || '';
+        }
+      }
+
+      if (!llmOutput) {
+        logger.warn('no_llm_output_for_memory');
+        return;
+      }
+
+      // Step 2: Parse JSON response
+      const memoryData = this.parseMemoryOutput(llmOutput);
+      if (!memoryData || !memoryData.memory) {
+        logger.debug(
+          { llmOutput: llmOutput.substring(0, 100) },
+          'no_valid_memory_generated'
+        );
+        return;
+      }
+
+      // Step 3: Generate embedding for the memory text
+      const embedResponse = await sharedEmbedder.embed(memoryData.memory);
+      const embedding = TextEmbedder.toArray(embedResponse);
+
+      // Step 4: Store memory in Supabase
+      const memoryRecord: MemoryRecord = {
+        userId,
+        content: memoryData.memory,
+        memoryType: memoryData.type,
+        topics: memoryData.topics,
+        importance: memoryData.importance,
+        embedding,
+      };
+
+      const memoryService = getMemoryService();
+      const memoryId = await memoryService.storeMemory(memoryRecord);
+
+      if (memoryId) {
+        logger.info(
+          {
+            memoryId,
+            type: memoryData.type,
+            topics: memoryData.topics,
+            importance: memoryData.importance,
+          },
+          'memory_created_successfully'
+        );
+      }
+    } catch (error) {
+      logger.error({ err: error }, 'memory_processing_error');
+    }
+  }
+
+  /**
+   * Parse LLM output to extract memory data
+   */
+  private parseMemoryOutput(llmOutput: string): MemoryGenerationOutput | null {
+    try {
+      // Find JSON in the output
+      const jsonMatch = llmOutput.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        return null;
+      }
+
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      // Validate required fields
+      if (!parsed.memory || typeof parsed.memory !== 'string') {
+        return null;
+      }
+
+      // Empty memory means nothing memorable
+      if (parsed.memory.trim() === '') {
+        return null;
+      }
+
+      // Validate and normalize type
+      const validTypes: MemoryType[] = [
+        'learning_progress',
+        'personal_context',
+      ];
+      const type: MemoryType = validTypes.includes(parsed.type)
+        ? parsed.type
+        : 'personal_context';
+
+      // Validate topics
+      const topics: string[] = Array.isArray(parsed.topics)
+        ? parsed.topics
+            .filter((t: unknown) => typeof t === 'string')
+            .slice(0, 5)
+        : [];
+
+      // Validate importance
+      const importance =
+        typeof parsed.importance === 'number'
+          ? Math.max(0, Math.min(1, parsed.importance))
+          : 0.5;
+
+      return {
+        memory: parsed.memory.trim(),
+        type,
+        topics,
+        importance,
+      };
+    } catch (error) {
+      logger.error(
+        { err: error, output: llmOutput.substring(0, 100) },
+        'memory_parse_error'
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Reset the processor (e.g., when starting a new conversation)
+   */
+  reset(): void {
+    this.turnCount = 0;
+  }
+}
diff --git a/backend/prompts/conversation.njk b/backend/prompts/conversation.njk
index e8d0bc3..e84733f 100644
--- a/backend/prompts/conversation.njk
+++ b/backend/prompts/conversation.njk
@@ -15,6 +15,13 @@
 - Generally, be terse, but expound if the user requests it
 - As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
 - Ask open-ended questions to prompt the user to practice their Spanish
+{% if relevant_memories and relevant_memories|length > 0 %}
+
+# What You Remember About This User
+{% for memory in relevant_memories %}
+- {{ memory.content }}{% if memory.memoryType == 'learning_progress' %} (learning note){% endif %}
+{% endfor %}
+{% endif %}
 
 {% if messages and messages|length > 0 %}
 Previous conversation:
diff --git a/backend/prompts/memory-generation.njk b/backend/prompts/memory-generation.njk
new file mode 100644
index 0000000..142a964
--- /dev/null
+++ b/backend/prompts/memory-generation.njk
@@ -0,0 +1,30 @@
+You are analyzing a language learning conversation to extract memorable facts about the user.
+
+Conversation context ({{target_language}} learning session):
+{% for message in messages %}
+{{ message.role }}: {{ message.content }}
+{% endfor %}
+
+Based on this conversation, create ONE concise memory about the user in English. Focus on:
+- Learning progress: vocabulary struggles, grammar issues, topics covered, skill improvements
+- Personal context: interests, goals, preferences, life details they shared
+
+Output format (JSON):
+{
+  "memory": "The user [specific fact about them]",
+  "type": "learning_progress" or "personal_context",
+  "topics": ["topic1", "topic2"],
+  "importance": 0.5
+}
+
+Rules:
+- Memory must be in English (even if conversation was in another language)
+- Keep it factual, specific, and concise (1-2 sentences)
+- Topics should be 1-3 relevant keywords
+- Importance scale:
+  - 0.3: Minor detail (casual mention)
+  - 0.5: Normal (general learning note or preference)
+  - 0.7: Significant (clear goal, major struggle, important interest)
+  - 0.9: Critical (explicit request to remember, strong preference)
+- If nothing memorable was said, return: {"memory": "", "type": "personal_context", "topics": [], "importance": 0}
+- Return ONLY the JSON object, no other text
diff --git a/backend/services/memory-service.ts b/backend/services/memory-service.ts
new file mode 100644
index 0000000..36c78f4
--- /dev/null
+++ b/backend/services/memory-service.ts
@@ -0,0 +1,248 @@
+/**
+ * Memory Service
+ *
+ * Handles memory storage and retrieval using Supabase with pgvector.
+ * Memories are stored in English with vector embeddings for semantic search.
+ */
+import { getSupabaseClient, isSupabaseConfigured } from '../config/supabase.js';
+import { MemoryRecord, MemoryMatch, MemoryType } from '../types/memory.js';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('MemoryService');
+
+/**
+ * Memory Service class for storing and retrieving user memories
+ */
+export class MemoryService {
+  /**
+   * Store a new memory with its embedding
+   * @param memory - The memory record to store
+   * @returns The ID of the stored memory, or null if storage failed
+   */
+  async storeMemory(memory: MemoryRecord): Promise<string | null> {
+    if (!isSupabaseConfigured()) {
+      logger.debug('supabase_not_configured_skipping_store');
+      return null;
+    }
+
+    try {
+      const supabase = getSupabaseClient();
+      if (!supabase) {
+        return null;
+      }
+
+      // Format embedding for Supabase pgvector
+      const embeddingStr = memory.embedding
+        ? `[${memory.embedding.join(',')}]`
+        : null;
+
+      const { data, error } = await supabase
+        .from('user_memories')
+        .insert({
+          user_id: memory.userId,
+          content: memory.content,
+          memory_type: memory.memoryType,
+          topics: memory.topics,
+          importance: memory.importance,
+          embedding: embeddingStr,
+        })
+        .select('id')
+        .single();
+
+      if (error) {
+        logger.error({ err: error }, 'failed_to_store_memory');
+        return null;
+      }
+
+      logger.info(
+        { memoryId: data.id, type: memory.memoryType, topics: memory.topics },
+        'memory_stored'
+      );
+      return data.id;
+    } catch (error) {
+      logger.error({ err: error }, 'memory_store_exception');
+      return null;
+    }
+  }
+
+  /**
+   * Retrieve similar memories using vector similarity search
+   * @param userId - The user's ID
+   * @param queryEmbedding - The embedding vector to search with
+   * @param limit - Maximum number of memories to return (default: 3)
+   * @param threshold - Minimum similarity threshold (default: 0.7)
+   * @returns Array of matching memories with similarity scores
+   */
+  async retrieveMemories(
+    userId: string,
+    queryEmbedding: number[],
+    limit: number = 3,
+    threshold: number = 0.7
+  ): Promise<MemoryMatch[]> {
+    if (!isSupabaseConfigured()) {
+      logger.debug('supabase_not_configured_skipping_retrieve');
+      return [];
+    }
+
+    try {
+      const supabase = getSupabaseClient();
+      if (!supabase) {
+        logger.warn('supabase_client_not_available');
+        return [];
+      }
+
+      // Format embedding for Supabase RPC call
+      const embeddingStr = `[${queryEmbedding.join(',')}]`;
+
+      logger.info(
+        { userId: userId.substring(0, 8), threshold, limit, embeddingLength: queryEmbedding.length },
+        'calling_match_memories_rpc'
+      );
+
+      const { data, error } = await supabase.rpc('match_memories', {
+        query_embedding: embeddingStr,
+        match_user_id: userId,
+        match_threshold: threshold,
+        match_count: limit,
+      });
+
+      if (error) {
+        logger.error({ err: error, code: error.code, message: error.message }, 'failed_to_retrieve_memories');
+        return [];
+      }
+
+      logger.info({ rawDataLength: data?.length || 0 }, 'match_memories_rpc_response');
+
+      const memories: MemoryMatch[] = (data || []).map(
+        (row: {
+          id: string;
+          content: string;
+          memory_type: string;
+          topics: string[];
+          importance: number;
+          similarity: number;
+        }) => ({
+          id: row.id,
+          content: row.content,
+          memoryType: row.memory_type as MemoryType,
+          topics: row.topics || [],
+          importance: row.importance,
+          similarity: row.similarity,
+        })
+      );
+
+      logger.debug(
+        { memoriesFound: memories.length, userId },
+        'memories_retrieved'
+      );
+
+      return memories;
+    } catch (error) {
+      logger.error({ err: error }, 'memory_retrieve_exception');
+      return [];
+    }
+  }
+
+  /**
+   * Get all memories for a user (for debugging/admin purposes)
+   * @param userId - The user's ID
+   * @param limit - Maximum number of memories to return (default: 50)
+   * @returns Array of memory records
+   */
+  async getUserMemories(
+    userId: string,
+    limit: number = 50
+  ): Promise<MemoryRecord[]> {
+    if (!isSupabaseConfigured()) {
+      return [];
+    }
+
+    try {
+      const supabase = getSupabaseClient();
+      if (!supabase) {
+        return [];
+      }
+
+      const { data, error } = await supabase
+        .from('user_memories')
+        .select('id, content, memory_type, topics, importance, created_at')
+        .eq('user_id', userId)
+        .order('created_at', { ascending: false })
+        .limit(limit);
+
+      if (error) {
+        logger.error({ err: error }, 'failed_to_get_user_memories');
+        return [];
+      }
+
+      return (data || []).map(
+        (row: {
+          id: string;
+          content: string;
+          memory_type: string;
+          topics: string[];
+          importance: number;
+          created_at: string;
+        }) => ({
+          id: row.id,
+          userId,
+          content: row.content,
+          memoryType: row.memory_type as MemoryType,
+          topics: row.topics || [],
+          importance: row.importance,
+          createdAt: row.created_at,
+        })
+      );
+    } catch (error) {
+      logger.error({ err: error }, 'get_user_memories_exception');
+      return [];
+    }
+  }
+
+  /**
+   * Delete a specific memory
+   * @param memoryId - The memory ID to delete
+   * @returns True if deleted successfully
+   */
+  async deleteMemory(memoryId: string): Promise<boolean> {
+    if (!isSupabaseConfigured()) {
+      return false;
+    }
+
+    try {
+      const supabase = getSupabaseClient();
+      if (!supabase) {
+        return false;
+      }
+
+      const { error } = await supabase
+        .from('user_memories')
+        .delete()
+        .eq('id', memoryId);
+
+      if (error) {
+        logger.error({ err: error, memoryId }, 'failed_to_delete_memory');
+        return false;
+      }
+
+      logger.info({ memoryId }, 'memory_deleted');
+      return true;
+    } catch (error) {
+      logger.error({ err: error }, 'delete_memory_exception');
+      return false;
+    }
+  }
+}
+
+// Singleton instance
+let memoryService: MemoryService | null = null;
+
+/**
+ * Get the singleton MemoryService instance
+ */
+export function getMemoryService(): MemoryService {
+  if (!memoryService) {
+    memoryService = new MemoryService();
+  }
+  return memoryService;
+}
diff --git a/backend/services/state.ts b/backend/services/state.ts
index 924fbc5..87fcffe 100644
--- a/backend/services/state.ts
+++ b/backend/services/state.ts
@@ -7,6 +7,7 @@
 import { ConnectionManager } from '../helpers/connection-manager.js';
 import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
 import { FeedbackProcessor } from '../helpers/feedback-processor.js';
+import { MemoryProcessor } from '../helpers/memory-processor.js';
 import { ConnectionsMap } from '../types/index.js';
 
 // Shared connections map (used by graph nodes)
@@ -16,6 +17,7 @@ export const connections: ConnectionsMap = {};
 export const connectionManagers = new Map<string, ConnectionManager>();
 export const flashcardProcessors = new Map<string, FlashcardProcessor>();
 export const feedbackProcessors = new Map<string, FeedbackProcessor>();
+export const memoryProcessors = new Map<string, MemoryProcessor>();
 export const connectionAttributes = new Map<
   string,
   { timezone?: string; userId?: string; languageCode?: string }
diff --git a/backend/services/websocket-handler.ts b/backend/services/websocket-handler.ts
index cb7a578..35201d6 100644
--- a/backend/services/websocket-handler.ts
+++ b/backend/services/websocket-handler.ts
@@ -11,6 +11,7 @@ import { GraphTypes } from '@inworld/runtime/graph';
 import { ConnectionManager } from '../helpers/connection-manager.js';
 import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
 import { FeedbackProcessor } from '../helpers/feedback-processor.js';
+import { MemoryProcessor } from '../helpers/memory-processor.js';
 import {
   getLanguageConfig,
   getSupportedLanguageCodes,
@@ -25,6 +26,7 @@ import {
   connectionManagers,
   flashcardProcessors,
   feedbackProcessors,
+  memoryProcessors,
   connectionAttributes,
   isShuttingDown,
 } from './state.js';
@@ -60,10 +62,14 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
     // Create feedback processor
     const feedbackProcessor = new FeedbackProcessor(defaultLanguageCode);
 
+    // Create memory processor
+    const memoryProcessor = new MemoryProcessor(defaultLanguageCode);
+
     // Store processors
     connectionManagers.set(connectionId, connectionManager);
     flashcardProcessors.set(connectionId, flashcardProcessor);
     feedbackProcessors.set(connectionId, feedbackProcessor);
+    memoryProcessors.set(connectionId, memoryProcessor);
     connectionAttributes.set(connectionId, {
       languageCode: defaultLanguageCode,
     });
@@ -162,6 +168,29 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
       }
     );
 
+    // Set up memory generation callback (fire-and-forget)
+    connectionManager.setMemoryCallback((messages) => {
+      if (isShuttingDown()) {
+        return;
+      }
+
+      const attrs = connectionAttributes.get(connectionId) || {};
+      const userId = attrs.userId;
+
+      if (!userId) {
+        // Can't create memories without a user ID
+        return;
+      }
+
+      // Increment turn and check if we should create a memory
+      memoryProcessor.incrementTurn();
+
+      if (memoryProcessor.shouldCreateMemory()) {
+        // Fire and forget - createMemoryAsync handles errors internally
+        memoryProcessor.createMemoryAsync(userId, messages);
+      }
+    });
+
     // Start the graph for this connection
     try {
       await connectionManager.start();
@@ -201,6 +230,7 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
       // Clean up other processors
       flashcardProcessors.delete(connectionId);
       feedbackProcessors.delete(connectionId);
+      memoryProcessors.delete(connectionId);
       connectionAttributes.delete(connectionId);
     });
   });
@@ -288,12 +318,14 @@ function handleLanguageChange(
     // Update all processors
     flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
     feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+    memoryProcessors.get(connectionId)?.setLanguage(newLanguageCode);
     connectionManager.setLanguage(newLanguageCode);
 
     // Reset conversation on language change
     connectionManager.reset();
     flashcardProcessors.get(connectionId)?.reset();
     feedbackProcessors.get(connectionId)?.reset();
+    memoryProcessors.get(connectionId)?.reset();
 
     // Send confirmation
     ws.send(
@@ -331,6 +363,14 @@ function handleUserContext(
     userId: userId || currentAttrs.userId,
     languageCode: languageCode || currentAttrs.languageCode,
   });
+
+  // Set user ID on connection manager for memory retrieval
+  if (userId) {
+    const manager = connectionManagers.get(connectionId);
+    if (manager) {
+      manager.setUserId(userId);
+    }
+  }
 }
 
 function handleFlashcardClicked(
diff --git a/backend/types/index.ts b/backend/types/index.ts
index 6ea7836..f159106 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -30,6 +30,8 @@ export interface State {
   languageCode: string;
   // Output modalities (for graph routing)
   output_modalities: ('text' | 'audio')[];
+  // User ID for memory retrieval/creation (optional - anonymous users won't have this)
+  userId?: string;
 }
 
 /**
diff --git a/backend/types/memory.ts b/backend/types/memory.ts
new file mode 100644
index 0000000..d12bc7b
--- /dev/null
+++ b/backend/types/memory.ts
@@ -0,0 +1,76 @@
+/**
+ * Memory Types for Language Learning App
+ *
+ * Defines interfaces for user memories - used for personalized conversations.
+ */
+
+/**
+ * Type of memory content
+ * - learning_progress: Info about user's language learning (vocabulary, grammar, struggles)
+ * - personal_context: Personal details shared by user (interests, goals, preferences)
+ */
+export type MemoryType = 'learning_progress' | 'personal_context';
+
+/**
+ * Memory record for storing in Supabase
+ */
+export interface MemoryRecord {
+  id?: string;
+  userId: string;
+
+  // Memory content (English)
+  content: string;
+
+  // Metadata
+  memoryType: MemoryType;
+  topics: string[];
+  importance: number; // 0.0 to 1.0
+
+  // Embedding (1024 dimensions for BAAI/bge-large-en-v1.5)
+  embedding?: number[];
+
+  // Timestamps
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+/**
+ * Memory match returned from similarity search
+ */
+export interface MemoryMatch {
+  id: string;
+  content: string;
+  memoryType: MemoryType;
+  topics: string[];
+  importance: number;
+  similarity: number; // Cosine similarity score (0.0 to 1.0)
+}
+
+/**
+ * Raw LLM output when generating a memory
+ */
+export interface MemoryGenerationOutput {
+  memory: string;
+  type: MemoryType;
+  topics: string[];
+  importance: number;
+}
+
+/**
+ * Input for memory creation
+ */
+export interface MemoryCreationInput {
+  userId: string;
+  messages: Array<{ role: string; content: string }>;
+  languageCode: string;
+}
+
+/**
+ * Input for memory retrieval
+ */
+export interface MemoryRetrievalInput {
+  userId: string;
+  queryText: string;
+  limit?: number;
+  threshold?: number;
+}
diff --git a/package-lock.json b/package-lock.json
index 2d4b43a..5ef5977 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -10,6 +10,7 @@
       "license": "MIT",
       "dependencies": {
         "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
+        "@supabase/supabase-js": "^2.89.0",
         "anki-apkg-export": "^4.0.3",
         "cors": "^2.8.5",
         "dotenv": "^17.2.1",
@@ -1374,6 +1375,86 @@
         "win32"
       ]
     },
+    "node_modules/@supabase/auth-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.89.0.tgz",
+      "integrity": "sha512-wiWZdz8WMad8LQdJMWYDZ2SJtZP5MwMqzQq3ehtW2ngiI3UTgbKiFrvMUUS3KADiVlk4LiGfODB2mrYx7w2f8w==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/functions-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.89.0.tgz",
+      "integrity": "sha512-XEueaC5gMe5NufNYfBh9kPwJlP5M2f+Ogr8rvhmRDAZNHgY6mI35RCkYDijd92pMcNM7g8pUUJov93UGUnqfyw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/postgrest-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.89.0.tgz",
+      "integrity": "sha512-/b0fKrxV9i7RNOEXMno/I1862RsYhuUo+Q6m6z3ar1f4ulTMXnDfv0y4YYxK2POcgrOXQOgKYQx1eArybyNvtg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/realtime-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.89.0.tgz",
+      "integrity": "sha512-aMOvfDb2a52u6PX6jrrjvACHXGV3zsOlWRzZsTIOAJa0hOVvRp01AwC1+nLTGUzxzezejrYeCX+KnnM1xHdl+w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/phoenix": "^1.6.6",
+        "@types/ws": "^8.18.1",
+        "tslib": "2.8.1",
+        "ws": "^8.18.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/storage-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.89.0.tgz",
+      "integrity": "sha512-6zKcXofk/M/4Eato7iqpRh+B+vnxeiTumCIP+Tz26xEqIiywzD9JxHq+udRrDuv6hXE+pmetvJd8n5wcf4MFRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "iceberg-js": "^0.8.1",
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/supabase-js": {
+      "version": "2.89.0",
+      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.89.0.tgz",
+      "integrity": "sha512-KlaRwSfFA0fD73PYVMHj5/iXFtQGCcX7PSx0FdQwYEEw9b2wqM7GxadY+5YwcmuEhalmjFB/YvqaoNVF+sWUlg==",
+      "license": "MIT",
+      "dependencies": {
+        "@supabase/auth-js": "2.89.0",
+        "@supabase/functions-js": "2.89.0",
+        "@supabase/postgrest-js": "2.89.0",
+        "@supabase/realtime-js": "2.89.0",
+        "@supabase/storage-js": "2.89.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@tsconfig/node-lts": {
       "version": "22.0.2",
       "resolved": "https://registry.npmjs.org/@tsconfig/node-lts/-/node-lts-22.0.2.tgz",
@@ -1500,6 +1581,12 @@
         "form-data": "^4.0.4"
       }
     },
+    "node_modules/@types/phoenix": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/@types/phoenix/-/phoenix-1.6.7.tgz",
+      "integrity": "sha512-oN9ive//QSBkf19rfDv45M7eZPi0eEXylht2OLEXicu5b4KoQ1OzXIw+xDSGWxSxe1JmepRR/ZH283vsu518/Q==",
+      "license": "MIT"
+    },
     "node_modules/@types/protobufjs": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/@types/protobufjs/-/protobufjs-6.0.0.tgz",
@@ -1551,7 +1638,6 @@
       "version": "8.18.1",
       "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
       "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/node": "*"
@@ -4206,6 +4292,15 @@
         "ms": "^2.0.0"
       }
     },
+    "node_modules/iceberg-js": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
+      "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/iconv-lite": {
       "version": "0.4.24",
       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
@@ -6541,6 +6636,12 @@
         "typescript": ">=4.8.4"
       }
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
     "node_modules/tsx": {
       "version": "4.20.6",
       "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.6.tgz",
diff --git a/package.json b/package.json
index 4ae5a88..827d222 100644
--- a/package.json
+++ b/package.json
@@ -53,6 +53,7 @@
   },
   "dependencies": {
     "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
+    "@supabase/supabase-js": "^2.89.0",
     "anki-apkg-export": "^4.0.3",
     "cors": "^2.8.5",
     "dotenv": "^17.2.1",
diff --git a/supabase/migrations/00001_schema.sql b/supabase/migrations/20250102000000_schema.sql
similarity index 100%
rename from supabase/migrations/00001_schema.sql
rename to supabase/migrations/20250102000000_schema.sql
diff --git a/supabase/migrations/20250106000000_memories.sql b/supabase/migrations/20250106000000_memories.sql
new file mode 100644
index 0000000..5ff0f90
--- /dev/null
+++ b/supabase/migrations/20250106000000_memories.sql
@@ -0,0 +1,88 @@
+-- Memory System Migration
+-- Adds user_memories table with pgvector for semantic memory retrieval
+
+-- Enable pgvector extension for vector similarity search
+create extension if not exists vector;
+
+-- User memories table (English only)
+create table public.user_memories (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+
+  -- Memory content (English)
+  content text not null,
+
+  -- Metadata
+  memory_type text check (memory_type in ('learning_progress', 'personal_context')) not null,
+  topics text[] default '{}',
+  importance float default 0.5,
+
+  -- Embedding (1024 dim for BAAI/bge-large-en-v1.5)
+  embedding vector(1024),
+
+  -- Timestamps
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+-- Index for vector similarity search using IVFFlat
+-- lists = 100 is a reasonable default; adjust based on table size
+create index idx_memories_embedding on public.user_memories
+  using ivfflat (embedding vector_cosine_ops) with (lists = 100);
+
+-- Index for user-based queries
+create index idx_memories_user on public.user_memories(user_id, created_at desc);
+
+-- Enable Row Level Security
+alter table public.user_memories enable row level security;
+
+-- RLS Policy: Users can only manage their own memories
+-- Note: Service role key bypasses RLS, which is what the backend uses
+create policy "Users manage own memories" on public.user_memories
+  for all using (auth.uid() = user_id);
+
+-- Function to search memories by cosine similarity
+create or replace function match_memories(
+  query_embedding vector(1024),
+  match_user_id uuid,
+  match_threshold float default 0.7,
+  match_count int default 3
+)
+returns table (
+  id uuid,
+  content text,
+  memory_type text,
+  topics text[],
+  importance float,
+  similarity float
+)
+language sql stable
+as $$
+  select
+    user_memories.id,
+    user_memories.content,
+    user_memories.memory_type,
+    user_memories.topics,
+    user_memories.importance,
+    1 - (user_memories.embedding <=> query_embedding) as similarity
+  from user_memories
+  where user_memories.user_id = match_user_id
+    and user_memories.embedding is not null
+    and 1 - (user_memories.embedding <=> query_embedding) > match_threshold
+  order by user_memories.embedding <=> query_embedding
+  limit match_count;
+$$;
+
+-- Trigger to update updated_at timestamp
+create or replace function update_updated_at_column()
+returns trigger as $$
+begin
+  new.updated_at = now();
+  return new;
+end;
+$$ language plpgsql;
+
+create trigger update_user_memories_updated_at
+  before update on public.user_memories
+  for each row
+  execute function update_updated_at_column();

From 2e7627c01a25079a8e0ee375a6dc76688c8f1c76 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Tue, 6 Jan 2026 17:28:12 -0800
Subject: [PATCH 29/49] fixed timeout issue

---
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   | 33 ++++++--
 backend/helpers/connection-manager.ts         | 84 +++++++++++++++++++
 2 files changed, 109 insertions(+), 8 deletions(-)

diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
index 8762622..3b566e9 100644
--- a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
+++ b/backend/graphs/nodes/assembly-ai-stt-ws-node.ts
@@ -48,8 +48,7 @@ class AssemblyAISession {
   constructor(
     public readonly sessionId: string,
     private apiKey: string,
-    private url: string,
-    private onCleanup: (sessionId: string) => void
+    private url: string
   ) {}
 
   /**
@@ -156,15 +155,29 @@ class AssemblyAISession {
     }, this.INACTIVITY_TIMEOUT_MS);
   }
 
+  /**
+   * Clear the inactivity timer without closing the connection.
+   * Used when we know no audio will be coming (e.g., text-only interactions).
+   */
+  public clearInactivityTimer(): void {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+      this.inactivityTimeout = null;
+    }
+  }
+
   private closeDueToInactivity(): void {
     const inactiveFor = Date.now() - this.lastActivityTime;
     logger.info(
       { sessionId: this.sessionId, inactiveMs: inactiveFor },
       'closing_due_to_inactivity'
     );
-    this.shouldStopProcessing = true;
-    this.close();
-    this.onCleanup(this.sessionId);
+    // Only close the WebSocket to stop billing, but keep the session reusable.
+    // Don't set shouldStopProcessing - this allows the graph to continue waiting
+    // for input and reconnect when audio arrives.
+    this.closeWebSocket();
+    // Note: We intentionally do NOT call onCleanup here anymore.
+    // The session stays in the map and can be reactivated by ensureConnection().
   }
 
   private closeWebSocket(): void {
@@ -367,8 +380,7 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
       session = new AssemblyAISession(
         sessionId,
         this.apiKey,
-        this.buildWebSocketUrl(),
-        (id) => this.sessions.delete(id)
+        this.buildWebSocketUrl()
       );
       this.sessions.set(sessionId, session);
     }
@@ -511,7 +523,12 @@ export class AssemblyAISTTWebSocketNode extends CustomNode {
               textContent = content.text;
               transcriptText = content.text;
               turnDetected = true;
-              if (session) session.shouldStopProcessing = true;
+              if (session) {
+                session.shouldStopProcessing = true;
+                // Clear inactivity timer since we're handling text, not audio
+                // This prevents the 60s timeout from firing and disrupting the session
+                session.clearInactivityTimer();
+              }
               turnResolve(transcriptText);
               break;
             }
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index 9d49f9d..b67f526 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -34,6 +34,10 @@ export class ConnectionManager {
   private languageCode: string;
   private languageConfig: LanguageConfig;
   private logger: ReturnType<typeof createSessionLogger>;
+  private restartAttempts = 0;
+  private readonly MAX_RESTART_ATTEMPTS = 3;
+  private lastRestartTime = 0;
+  private readonly RESTART_COOLDOWN_MS = 5000; // Prevent rapid restart loops
 
   // Callback for flashcard processing
   private flashcardCallback:
@@ -187,6 +191,86 @@ export class ConnectionManager {
     }
 
     this.logger.info('graph_execution_completed');
+
+    // Auto-restart if the graph completed but we weren't destroyed
+    // This handles timeout scenarios (DEADLINE_EXCEEDED) gracefully
+    if (!this.isDestroyed) {
+      await this.handleGraphCompletion();
+    }
+  }
+
+  /**
+   * Handle unexpected graph completion by restarting
+   */
+  private async handleGraphCompletion(): Promise<void> {
+    const now = Date.now();
+    const timeSinceLastRestart = now - this.lastRestartTime;
+
+    // Reset restart attempts if enough time has passed (successful operation)
+    if (timeSinceLastRestart > 30000) {
+      this.restartAttempts = 0;
+    }
+
+    // Check if we should attempt restart
+    if (this.restartAttempts >= this.MAX_RESTART_ATTEMPTS) {
+      this.logger.warn(
+        { attempts: this.restartAttempts },
+        'max_restart_attempts_reached'
+      );
+      this.sendToClient({
+        type: 'error',
+        message:
+          'Connection lost. Please refresh the page to continue the conversation.',
+        code: 'GRAPH_RESTART_FAILED',
+        timestamp: Date.now(),
+      });
+      return;
+    }
+
+    // Cooldown check to prevent rapid restart loops
+    if (timeSinceLastRestart < this.RESTART_COOLDOWN_MS) {
+      this.logger.debug(
+        { cooldownMs: this.RESTART_COOLDOWN_MS - timeSinceLastRestart },
+        'restart_cooldown_active'
+      );
+      await new Promise((resolve) =>
+        setTimeout(resolve, this.RESTART_COOLDOWN_MS - timeSinceLastRestart)
+      );
+    }
+
+    this.restartAttempts++;
+    this.lastRestartTime = Date.now();
+
+    this.logger.info(
+      { attempt: this.restartAttempts },
+      'auto_restarting_graph_after_timeout'
+    );
+
+    // Create a fresh multimodal stream manager
+    this.multimodalStreamManager = new MultimodalStreamManager();
+
+    // Update the connection's reference to the new stream manager
+    const connection = this.connections[this.sessionId];
+    if (connection) {
+      connection.multimodalStreamManager = this.multimodalStreamManager;
+    }
+
+    // Notify client that we're recovering
+    this.sendToClient({
+      type: 'connection_recovered',
+      message: 'Connection restored after idle timeout.',
+      timestamp: Date.now(),
+    });
+
+    // Restart graph execution
+    const multimodalStream = this.createMultimodalStreamGenerator();
+    this.graphExecution = this.executeGraph(multimodalStream);
+
+    this.graphExecution.catch((error) => {
+      if (!this.isDestroyed) {
+        this.logger.error({ err: error }, 'graph_restart_error');
+      }
+    });
   }
 
   /**

From 89181ab3e1c43dffecb97b51d85371215b9def2b Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 7 Jan 2026 15:28:07 -0800
Subject: [PATCH 30/49] added supabase setup for storing and retrieving
 memories

---
 README.md                                     |  18 +-
 backend/config/supabase.ts                    |   6 +-
 backend/graphs/conversation-graph.ts          |   1 -
 .../nodes/dialog-prompt-builder-node.ts       |   8 +-
 backend/graphs/nodes/memory-retrieval-node.ts |  69 +++++---
 backend/helpers/connection-manager.ts         |   3 +-
 backend/helpers/memory-processor.ts           |  12 +-
 backend/services/memory-service.ts            |  86 +++++-----
 backend/services/websocket-handler.ts         |   4 +-
 backend/types/index.ts                        |  10 ++
 backend/types/memory.ts                       |  30 ++++
 .../src/__tests__/services/Storage.test.ts    |  21 ---
 frontend/src/context/AppContext.tsx           |  18 +-
 frontend/src/services/Storage.ts              |  18 --
 frontend/src/styles/main.css                  |   1 +
 frontend/src/types/index.ts                   |   2 +-
 .../00000000000000_initial_schema.sql         | 156 ++++++++++++++++++
 supabase/migrations/20250102000000_schema.sql |  62 -------
 .../migrations/20250106000000_memories.sql    |  88 ----------
 19 files changed, 341 insertions(+), 272 deletions(-)
 create mode 100644 supabase/migrations/00000000000000_initial_schema.sql
 delete mode 100644 supabase/migrations/20250102000000_schema.sql
 delete mode 100644 supabase/migrations/20250106000000_memories.sql

diff --git a/README.md b/README.md
index f7a6762..6a1ce9f 100644
--- a/README.md
+++ b/README.md
@@ -62,7 +62,7 @@ npm run build
 npm start
 ```
 
-### Step 5 (Optional): Set Up Supabase for User Auth
+### Step 5 (Optional): Set Up Supabase for Auth & Memory
 
 Without Supabase, the app works in anonymous mode using localStorage.
 
@@ -76,6 +76,8 @@ npx supabase link --project-ref YOUR_PROJECT_REF
 npx supabase db push
 ```
 
+This creates all tables, indexes, RLS policies, and the `match_memories` function for semantic search.
+
 Find your project ref in the Supabase dashboard URL: `supabase.com/dashboard/project/YOUR_PROJECT_REF`
 
 **c) Add Supabase variables to `.env` (root):**
@@ -137,6 +139,20 @@ The app uses a real-time audio streaming architecture:
 3. **Flashcards** are auto-generated from conversation vocabulary
 4. **Response feedback** provides grammar and usage corrections
 
+## Memory System
+
+When Supabase is configured, the app stores and retrieves user memories using semantic search:
+
+- **Automatic memory creation**: Every few conversation turns, the system extracts memorable facts
+- **Semantic retrieval**: Relevant memories are retrieved using vector similarity search (pgvector)
+- **Personalized responses**: The AI uses retrieved memories to personalize conversations
+
+Memory types:
+- `learning_progress`: Vocabulary struggles, grammar patterns, learning achievements
+- `personal_context`: Interests, goals, preferences shared by the user
+
+Without Supabase, the app works in anonymous mode using localStorage (no memory persistence).
+
 ## Environment Variables Reference
 
 | Variable                     | Required | Description                                                        |
diff --git a/backend/config/supabase.ts b/backend/config/supabase.ts
index 2ca8d5f..ca4efb1 100644
--- a/backend/config/supabase.ts
+++ b/backend/config/supabase.ts
@@ -5,6 +5,9 @@
  * Uses service role key for admin access (bypasses RLS).
  */
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('Supabase');
 
 let supabaseClient: SupabaseClient | null = null;
 
@@ -21,7 +24,7 @@ export function getSupabaseClient(): SupabaseClient | null {
   const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
 
   if (!supabaseUrl || !supabaseServiceKey) {
-    // Supabase not configured - memory features will be disabled
+    logger.debug('supabase_not_configured');
     return null;
   }
 
@@ -32,6 +35,7 @@ export function getSupabaseClient(): SupabaseClient | null {
     },
   });
 
+  logger.info('supabase_client_initialized');
   return supabaseClient;
 }
 
diff --git a/backend/graphs/conversation-graph.ts b/backend/graphs/conversation-graph.ts
index 1a8b58a..efd6b00 100644
--- a/backend/graphs/conversation-graph.ts
+++ b/backend/graphs/conversation-graph.ts
@@ -127,7 +127,6 @@ export class ConversationGraphWrapper {
 
     const memoryRetrievalNode = new MemoryRetrievalNode({
       id: `memory-retrieval-node${postfix}`,
-      connections,
       reportToClient: false,
     });
 
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/graphs/nodes/dialog-prompt-builder-node.ts
index 6e8be53..637cc56 100644
--- a/backend/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/graphs/nodes/dialog-prompt-builder-node.ts
@@ -10,17 +10,11 @@
 
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
-import { ConnectionsMap, State } from '../../types/index.js';
-import { MemoryMatch } from '../../types/memory.js';
+import { ConnectionsMap, StateWithMemories } from '../../types/index.js';
 import { getLanguageConfig } from '../../config/languages.js';
 import { conversationTemplate } from '../../helpers/prompt-templates.js';
 import { graphLogger as logger } from '../../utils/logger.js';
 
-// Extended state type that includes memories
-export interface StateWithMemories extends State {
-  relevantMemories?: MemoryMatch[];
-}
-
 export class DialogPromptBuilderNode extends CustomNode {
   constructor(props: {
     id: string;
diff --git a/backend/graphs/nodes/memory-retrieval-node.ts b/backend/graphs/nodes/memory-retrieval-node.ts
index 931dd64..4ed0a5a 100644
--- a/backend/graphs/nodes/memory-retrieval-node.ts
+++ b/backend/graphs/nodes/memory-retrieval-node.ts
@@ -10,19 +10,20 @@
 
 import { CustomNode, ProcessContext } from '@inworld/runtime/graph';
 import { TextEmbedder } from '@inworld/runtime/primitives/embeddings';
-import { State, ConnectionsMap } from '../../types/index.js';
-import { MemoryMatch } from '../../types/memory.js';
+import { State, StateWithMemories } from '../../types/index.js';
 import { getMemoryService } from '../../services/memory-service.js';
 import { isSupabaseConfigured } from '../../config/supabase.js';
 import { embedderConfig } from '../../config/embedder.js';
 import { graphLogger as logger } from '../../utils/logger.js';
 
-/**
- * Extended state with relevant memories
- */
-export interface StateWithMemories extends State {
-  relevantMemories?: MemoryMatch[];
-}
+// Re-export for backwards compatibility
+export type { StateWithMemories } from '../../types/index.js';
+
+/** Maximum number of memories to retrieve */
+const MEMORY_RETRIEVAL_LIMIT = 3;
+
+/** Minimum similarity threshold for memory matches */
+const MEMORY_SIMILARITY_THRESHOLD = 0.5;
 
 // Singleton embedder - shared across all MemoryRetrievalNode instances
 let sharedEmbedder: TextEmbedder | null = null;
@@ -42,9 +43,14 @@ async function initSharedEmbedder(): Promise<void> {
 
   sharedInitPromise = (async () => {
     try {
+      const apiKey = process.env.INWORLD_API_KEY;
+      if (!apiKey) {
+        throw new Error('INWORLD_API_KEY environment variable is required');
+      }
+
       sharedEmbedder = await TextEmbedder.create({
         remoteConfig: {
-          apiKey: process.env.INWORLD_API_KEY!,
+          apiKey,
           provider: embedderConfig.provider,
           modelName: embedderConfig.modelName,
         },
@@ -61,28 +67,36 @@ async function initSharedEmbedder(): Promise<void> {
 }
 
 export class MemoryRetrievalNode extends CustomNode {
-  constructor(props: {
-    id: string;
-    connections: ConnectionsMap;
-    reportToClient?: boolean;
-  }) {
+  constructor(props: { id: string; reportToClient?: boolean }) {
     super({
       id: props.id,
       reportToClient: props.reportToClient,
     });
-    logger.info({ nodeId: props.id }, 'memory_retrieval_node_constructed');
     // Note: embedder is initialized lazily on first use, not during construction
   }
 
+  /**
+   * Cleanup method for pattern consistency with other nodes
+   */
+  destroy(): void {
+    // Embedder is shared singleton, not destroyed per-node
+  }
+
   async process(
-    context: ProcessContext,
+    _context: ProcessContext,
     state: State
   ): Promise<StateWithMemories> {
-    logger.info({ nodeId: this.id, hasState: !!state }, 'memory_retrieval_node_entered');
+    logger.info(
+      { nodeId: this.id, hasState: !!state },
+      'memory_retrieval_node_entered'
+    );
 
     // Get user ID from state (flows through the graph from connection.state)
     const userId = state.userId;
-    logger.info({ userId: userId?.substring(0, 8) }, 'memory_retrieval_got_userId');
+    logger.info(
+      { userId: userId?.substring(0, 8) },
+      'memory_retrieval_got_userId'
+    );
 
     // If no userId or Supabase not configured, skip memory retrieval
     if (!userId || !isSupabaseConfigured()) {
@@ -104,7 +118,10 @@ export class MemoryRetrievalNode extends CustomNode {
 
     try {
       logger.info(
-        { userId: userId.substring(0, 8), userMessage: lastUserMessage.content.substring(0, 50) },
+        {
+          userId: userId.substring(0, 8),
+          userMessage: lastUserMessage.content.substring(0, 50),
+        },
         'memory_retrieval_starting'
       );
 
@@ -120,22 +137,28 @@ export class MemoryRetrievalNode extends CustomNode {
       logger.debug('embedding_user_message');
       const embedResponse = await sharedEmbedder.embed(lastUserMessage.content);
       const queryEmbedding = TextEmbedder.toArray(embedResponse);
-      logger.debug({ embeddingLength: queryEmbedding.length }, 'embedding_generated');
+      logger.debug(
+        { embeddingLength: queryEmbedding.length },
+        'embedding_generated'
+      );
 
       // Retrieve similar memories
       const memoryService = getMemoryService();
       const memories = await memoryService.retrieveMemories(
         userId,
         queryEmbedding,
-        3, // limit: up to 3 memories
-        0.5 // threshold: lowered from 0.65 for testing
+        MEMORY_RETRIEVAL_LIMIT,
+        MEMORY_SIMILARITY_THRESHOLD
       );
 
       logger.info(
         {
           memoriesFound: memories.length,
           userId: userId.substring(0, 8),
-          memories: memories.map(m => ({ content: m.content.substring(0, 50), similarity: m.similarity }))
+          memories: memories.map((m) => ({
+            content: m.content.substring(0, 50),
+            similarity: m.similarity,
+          })),
         },
         'memories_retrieved_for_prompt'
       );
diff --git a/backend/helpers/connection-manager.ts b/backend/helpers/connection-manager.ts
index b67f526..2fc9f8a 100644
--- a/backend/helpers/connection-manager.ts
+++ b/backend/helpers/connection-manager.ts
@@ -38,6 +38,7 @@ export class ConnectionManager {
   private readonly MAX_RESTART_ATTEMPTS = 3;
   private lastRestartTime = 0;
   private readonly RESTART_COOLDOWN_MS = 5000; // Prevent rapid restart loops
+  private readonly RESTART_RESET_THRESHOLD_MS = 30000; // Reset attempts after stable operation
 
   // Callback for flashcard processing
   private flashcardCallback:
@@ -207,7 +208,7 @@ export class ConnectionManager {
     const timeSinceLastRestart = now - this.lastRestartTime;
 
     // Reset restart attempts if enough time has passed (successful operation)
-    if (timeSinceLastRestart > 30000) {
+    if (timeSinceLastRestart > this.RESTART_RESET_THRESHOLD_MS) {
       this.restartAttempts = 0;
     }
 
diff --git a/backend/helpers/memory-processor.ts b/backend/helpers/memory-processor.ts
index 73fdc59..32aa2a4 100644
--- a/backend/helpers/memory-processor.ts
+++ b/backend/helpers/memory-processor.ts
@@ -31,6 +31,9 @@ import { createLogger } from '../utils/logger.js';
 
 const logger = createLogger('MemoryProcessor');
 
+/** Number of recent messages to include for memory generation context */
+const MEMORY_MESSAGE_CONTEXT_LIMIT = 10;
+
 // Singleton graph instance - shared across all MemoryProcessor instances
 let sharedGraph: Graph | null = null;
 let sharedEmbedder: TextEmbedder | null = null;
@@ -50,10 +53,15 @@ async function initSharedResources(): Promise<void> {
 
   sharedInitPromise = (async () => {
     try {
+      const apiKey = process.env.INWORLD_API_KEY;
+      if (!apiKey) {
+        throw new Error('INWORLD_API_KEY environment variable is required');
+      }
+
       // Initialize embedder
       sharedEmbedder = await TextEmbedder.create({
         remoteConfig: {
-          apiKey: process.env.INWORLD_API_KEY!,
+          apiKey,
           provider: embedderConfig.provider,
           modelName: embedderConfig.modelName,
         },
@@ -157,7 +165,7 @@ export class MemoryProcessor {
 
       // Step 1: Generate memory using LLM
       const input = {
-        messages: messages.slice(-10), // Last 10 messages for context
+        messages: messages.slice(-MEMORY_MESSAGE_CONTEXT_LIMIT),
         target_language: langConfig.name,
       };
 
diff --git a/backend/services/memory-service.ts b/backend/services/memory-service.ts
index 36c78f4..96e85e9 100644
--- a/backend/services/memory-service.ts
+++ b/backend/services/memory-service.ts
@@ -5,9 +5,26 @@
  * Memories are stored in English with vector embeddings for semantic search.
  */
 import { getSupabaseClient, isSupabaseConfigured } from '../config/supabase.js';
-import { MemoryRecord, MemoryMatch, MemoryType } from '../types/memory.js';
+import {
+  MemoryRecord,
+  MemoryMatch,
+  MemoryType,
+  SupabaseMemoryRow,
+  VALID_MEMORY_TYPES,
+} from '../types/memory.js';
 import { createLogger } from '../utils/logger.js';
 
+/**
+ * Validate and convert a memory_type string to MemoryType
+ */
+function validateMemoryType(type: string): MemoryType {
+  if (VALID_MEMORY_TYPES.includes(type as MemoryType)) {
+    return type as MemoryType;
+  }
+  // Default to personal_context for unknown types
+  return 'personal_context';
+}
+
 const logger = createLogger('MemoryService');
 
 /**
@@ -94,10 +111,7 @@ export class MemoryService {
       // Format embedding for Supabase RPC call
       const embeddingStr = `[${queryEmbedding.join(',')}]`;
 
-      logger.info(
-        { userId: userId.substring(0, 8), threshold, limit, embeddingLength: queryEmbedding.length },
-        'calling_match_memories_rpc'
-      );
+      const startTime = performance.now();
 
       const { data, error } = await supabase.rpc('match_memories', {
         query_embedding: embeddingStr,
@@ -106,36 +120,37 @@ export class MemoryService {
         match_count: limit,
       });
 
+      const elapsed = performance.now() - startTime;
+
       if (error) {
-        logger.error({ err: error, code: error.code, message: error.message }, 'failed_to_retrieve_memories');
+        logger.error(
+          { err: error, code: error.code, message: error.message },
+          'failed_to_retrieve_memories'
+        );
         return [];
       }
 
-      logger.info({ rawDataLength: data?.length || 0 }, 'match_memories_rpc_response');
+      logger.info(
+        {
+          memoriesFound: data?.length || 0,
+          queryTimeMs: elapsed.toFixed(2),
+          threshold,
+          limit,
+        },
+        'memories_retrieved'
+      );
 
       const memories: MemoryMatch[] = (data || []).map(
-        (row: {
-          id: string;
-          content: string;
-          memory_type: string;
-          topics: string[];
-          importance: number;
-          similarity: number;
-        }) => ({
+        (row: SupabaseMemoryRow) => ({
           id: row.id,
           content: row.content,
-          memoryType: row.memory_type as MemoryType,
+          memoryType: validateMemoryType(row.memory_type),
           topics: row.topics || [],
           importance: row.importance,
-          similarity: row.similarity,
+          similarity: row.similarity ?? 0,
         })
       );
 
-      logger.debug(
-        { memoriesFound: memories.length, userId },
-        'memories_retrieved'
-      );
-
       return memories;
     } catch (error) {
       logger.error({ err: error }, 'memory_retrieve_exception');
@@ -175,24 +190,15 @@ export class MemoryService {
         return [];
       }
 
-      return (data || []).map(
-        (row: {
-          id: string;
-          content: string;
-          memory_type: string;
-          topics: string[];
-          importance: number;
-          created_at: string;
-        }) => ({
-          id: row.id,
-          userId,
-          content: row.content,
-          memoryType: row.memory_type as MemoryType,
-          topics: row.topics || [],
-          importance: row.importance,
-          createdAt: row.created_at,
-        })
-      );
+      return (data || []).map((row: SupabaseMemoryRow) => ({
+        id: row.id,
+        userId,
+        content: row.content,
+        memoryType: validateMemoryType(row.memory_type),
+        topics: row.topics || [],
+        importance: row.importance,
+        createdAt: row.created_at,
+      }));
     } catch (error) {
       logger.error({ err: error }, 'get_user_memories_exception');
       return [];
diff --git a/backend/services/websocket-handler.ts b/backend/services/websocket-handler.ts
index 35201d6..de34304 100644
--- a/backend/services/websocket-handler.ts
+++ b/backend/services/websocket-handler.ts
@@ -348,9 +348,9 @@ function handleUserContext(
   connectionId: string,
   message: {
     timezone?: string;
-    userId?: string;
+    userId?: string | null;
     languageCode?: string;
-    data?: { timezone?: string; userId?: string; languageCode?: string };
+    data?: { timezone?: string; userId?: string | null; languageCode?: string };
   }
 ): void {
   const timezone = message.timezone || message.data?.timezone;
diff --git a/backend/types/index.ts b/backend/types/index.ts
index f159106..beed25d 100644
--- a/backend/types/index.ts
+++ b/backend/types/index.ts
@@ -75,3 +75,13 @@ export interface InteractionInfo {
   text: string;
   interactionComplete: boolean;
 }
+
+// Re-export memory types for convenience
+export type {
+  MemoryType,
+  MemoryRecord,
+  MemoryMatch,
+  StateWithMemories,
+  SupabaseMemoryRow,
+} from './memory.js';
+export { VALID_MEMORY_TYPES } from './memory.js';
diff --git a/backend/types/memory.ts b/backend/types/memory.ts
index d12bc7b..382b22f 100644
--- a/backend/types/memory.ts
+++ b/backend/types/memory.ts
@@ -4,6 +4,8 @@
  * Defines interfaces for user memories - used for personalized conversations.
  */
 
+import type { State } from './index.js';
+
 /**
  * Type of memory content
  * - learning_progress: Info about user's language learning (vocabulary, grammar, struggles)
@@ -11,6 +13,12 @@
  */
 export type MemoryType = 'learning_progress' | 'personal_context';
 
+/** Valid memory types for runtime validation */
+export const VALID_MEMORY_TYPES: MemoryType[] = [
+  'learning_progress',
+  'personal_context',
+];
+
 /**
  * Memory record for storing in Supabase
  */
@@ -74,3 +82,25 @@ export interface MemoryRetrievalInput {
   limit?: number;
   threshold?: number;
 }
+
+/**
+ * Extended state with relevant memories attached
+ * Used by MemoryRetrievalNode and DialogPromptBuilderNode
+ */
+export interface StateWithMemories extends State {
+  relevantMemories?: MemoryMatch[];
+}
+
+/**
+ * Raw row format from Supabase user_memories table
+ * Used for type-safe database row mapping
+ */
+export interface SupabaseMemoryRow {
+  id: string;
+  content: string;
+  memory_type: string;
+  topics: string[];
+  importance: number;
+  similarity?: number;
+  created_at?: string;
+}
diff --git a/frontend/src/__tests__/services/Storage.test.ts b/frontend/src/__tests__/services/Storage.test.ts
index 0eaf070..1bb9f17 100644
--- a/frontend/src/__tests__/services/Storage.test.ts
+++ b/frontend/src/__tests__/services/Storage.test.ts
@@ -25,27 +25,6 @@ describe('Storage', () => {
     });
   });
 
-  describe('getOrCreateUserId', () => {
-    it('creates a user ID on first call', () => {
-      const id = storage.getOrCreateUserId();
-      expect(id).toBeTruthy();
-      expect(typeof id).toBe('string');
-    });
-
-    it('returns same ID on subsequent calls', () => {
-      const id1 = storage.getOrCreateUserId();
-      const id2 = storage.getOrCreateUserId();
-      expect(id1).toBe(id2);
-    });
-
-    it('persists user ID across instances', () => {
-      const id1 = storage.getOrCreateUserId();
-      const newStorage = new Storage();
-      const id2 = newStorage.getOrCreateUserId();
-      expect(id1).toBe(id2);
-    });
-  });
-
   describe('addMessage', () => {
     it('adds message to conversation history', () => {
       storage.addMessage('user', 'Hello');
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 7d9778d..0de3db0 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -70,7 +70,8 @@ type AppAction =
   | { type: 'SET_SIDEBAR_OPEN'; payload: boolean }
   | { type: 'ADD_CONVERSATION'; payload: ConversationSummary }
   | { type: 'REMOVE_CONVERSATION'; payload: string }
-  | { type: 'RENAME_CONVERSATION'; payload: { id: string; title: string } };
+  | { type: 'RENAME_CONVERSATION'; payload: { id: string; title: string } }
+  | { type: 'SET_USER_ID'; payload: string | null };
 
 // Initial state
 const createInitialState = (storage: HybridStorage): AppState => ({
@@ -88,7 +89,7 @@ const createInitialState = (storage: HybridStorage): AppState => ({
   flashcards: [],
   pronouncingCardId: null,
   feedbackMap: {},
-  userId: storage.getOrCreateUserId(),
+  userId: null,
   conversations: [],
   currentConversationId: null,
   sidebarOpen: false,
@@ -199,6 +200,8 @@ function appReducer(state: AppState, action: AppAction): AppState {
             : c
         ),
       };
+    case 'SET_USER_ID':
+      return { ...state, userId: action.payload };
     default:
       return state;
   }
@@ -257,6 +260,9 @@ export function AppProvider({ children }: AppProviderProps) {
     const storage = storageRef.current;
 
     if (supabase && user) {
+      // Immediately update userId from auth
+      dispatch({ type: 'SET_USER_ID', payload: user.id });
+
       storage.setSupabaseClient(supabase, user.id);
 
       // Sync data on login
@@ -315,6 +321,9 @@ export function AppProvider({ children }: AppProviderProps) {
           .catch(console.error);
       }
     } else {
+      // Clear userId on logout
+      dispatch({ type: 'SET_USER_ID', payload: null });
+
       storage.clearSupabaseClient();
       hasMigratedRef.current = false;
     }
@@ -994,14 +1003,15 @@ export function AppProvider({ children }: AppProviderProps) {
         wsClient.send({
           type: 'user_context',
           timezone: tz,
-          userId: state.userId,
+          // Use auth user ID - will be null if not authenticated
+          userId: user?.id || null,
           languageCode: state.currentLanguage,
         });
       } catch {
         // ignore
       }
     }
-  }, [state.connectionStatus, state.userId, state.currentLanguage]);
+  }, [state.connectionStatus, user, state.currentLanguage]);
 
   // Toggle recording
   const toggleRecording = useCallback(async () => {
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index ae3056d..8ea6e7a 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -15,24 +15,6 @@ export class Storage {
   private flashcardsKey = 'aprende-flashcards'; // Legacy per-language flashcards
   private flashcardsConversationKeyPrefix = 'aprende-flashcards-conv-'; // + conversationId
   private languageKey = 'aprende-language';
-  private userIdKey = 'aprende-user-id';
-
-  // User ID methods
-  getOrCreateUserId(): string {
-    try {
-      let id = localStorage.getItem(this.userIdKey);
-      if (!id) {
-        id =
-          typeof crypto !== 'undefined' && crypto.randomUUID
-            ? crypto.randomUUID()
-            : `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-        localStorage.setItem(this.userIdKey, id);
-      }
-      return id;
-    } catch {
-      return `u_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-    }
-  }
 
   // Language preference methods
   getLanguage(): string {
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index bc5bc66..70835e3 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -44,6 +44,7 @@ body {
 /* Sidebar */
 .sidebar {
     width: 260px;
+    height: 100%;
     background: #f9fafb;
     border-right: 1px solid #e5e5e5;
     display: flex;
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 9008cc1..97bdac5 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -153,7 +153,7 @@ export interface AppState {
   feedbackMap: Record<string, string>;
 
   // User
-  userId: string;
+  userId: string | null;
 
   // Multi-conversation support
   conversations: ConversationSummary[];
diff --git a/supabase/migrations/00000000000000_initial_schema.sql b/supabase/migrations/00000000000000_initial_schema.sql
new file mode 100644
index 0000000..843230e
--- /dev/null
+++ b/supabase/migrations/00000000000000_initial_schema.sql
@@ -0,0 +1,156 @@
+-- Inworld Language Tutor - Complete Database Schema
+-- Run with: npx supabase db push
+-- This creates all tables, indexes, RLS policies, and functions
+
+--------------------------------------------------------------------------------
+-- Extensions
+--------------------------------------------------------------------------------
+
+-- Enable pgvector for semantic memory search
+create extension if not exists vector;
+
+--------------------------------------------------------------------------------
+-- Core Tables
+--------------------------------------------------------------------------------
+
+-- User preferences (language preference)
+create table public.user_preferences (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null unique,
+  language_code text default 'es' not null,
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+-- Conversations (multi-conversation support, per language)
+create table public.conversations (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+  language_code text not null,
+  title text not null,
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+-- Conversation messages (belong to a conversation)
+create table public.conversation_messages (
+  id uuid primary key default gen_random_uuid(),
+  conversation_id uuid references public.conversations(id) on delete cascade not null,
+  role text check (role in ('user', 'assistant')) not null,
+  content text not null,
+  created_at timestamptz default now() not null
+);
+
+-- Flashcards (per user per conversation)
+create table public.flashcards (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+  language_code text not null,
+  conversation_id uuid references public.conversations(id) on delete cascade,
+  target_word text not null,
+  english text not null,
+  example text,
+  mnemonic text,
+  created_at timestamptz default now() not null,
+  unique(user_id, conversation_id, target_word)
+);
+
+--------------------------------------------------------------------------------
+-- Memory System (pgvector)
+--------------------------------------------------------------------------------
+
+-- User memories with embeddings for semantic search
+create table public.user_memories (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid references auth.users(id) on delete cascade not null,
+  content text not null,
+  memory_type text check (memory_type in ('learning_progress', 'personal_context')) not null,
+  topics text[] default '{}',
+  importance float default 0.5,
+  embedding vector(1024), -- BAAI/bge-large-en-v1.5 model
+  created_at timestamptz default now() not null,
+  updated_at timestamptz default now() not null
+);
+
+--------------------------------------------------------------------------------
+-- Indexes
+--------------------------------------------------------------------------------
+
+-- Core table indexes
+create index idx_conversations_user_lang on public.conversations(user_id, language_code, updated_at desc);
+create index idx_messages_conversation on public.conversation_messages(conversation_id, created_at);
+create index idx_flashcards_conversation on public.flashcards(user_id, conversation_id);
+
+-- Memory indexes
+create index idx_memories_embedding on public.user_memories
+  using ivfflat (embedding vector_cosine_ops) with (lists = 100);
+create index idx_memories_user on public.user_memories(user_id, created_at desc);
+
+--------------------------------------------------------------------------------
+-- Row Level Security
+--------------------------------------------------------------------------------
+
+alter table public.user_preferences enable row level security;
+alter table public.conversations enable row level security;
+alter table public.conversation_messages enable row level security;
+alter table public.flashcards enable row level security;
+alter table public.user_memories enable row level security;
+
+-- RLS Policies (users can only access their own data)
+-- Note: Service role key bypasses RLS, which is what the backend uses
+create policy "Users manage own preferences" on public.user_preferences for all using (auth.uid() = user_id);
+create policy "Users manage own conversations" on public.conversations for all using (auth.uid() = user_id);
+create policy "Users manage own messages" on public.conversation_messages for all
+  using (conversation_id in (select id from public.conversations where user_id = auth.uid()));
+create policy "Users manage own flashcards" on public.flashcards for all using (auth.uid() = user_id);
+create policy "Users manage own memories" on public.user_memories for all using (auth.uid() = user_id);
+
+--------------------------------------------------------------------------------
+-- Functions
+--------------------------------------------------------------------------------
+
+-- Search memories by cosine similarity (optimized for index usage)
+create or replace function match_memories(
+  query_embedding vector(1024),
+  match_user_id uuid,
+  match_threshold float default 0.7,
+  match_count int default 3
+)
+returns table (
+  id uuid,
+  content text,
+  memory_type text,
+  topics text[],
+  importance float,
+  similarity float
+)
+language sql stable
+as $$
+  select
+    user_memories.id,
+    user_memories.content,
+    user_memories.memory_type,
+    user_memories.topics,
+    user_memories.importance,
+    1 - (user_memories.embedding <=> query_embedding) as similarity
+  from user_memories
+  where user_memories.user_id = match_user_id
+    and user_memories.embedding is not null
+    and user_memories.embedding <=> query_embedding < (1 - match_threshold)
+  order by user_memories.embedding <=> query_embedding
+  limit match_count;
+$$;
+
+-- Trigger function to auto-update timestamps
+create or replace function update_updated_at_column()
+returns trigger as $$
+begin
+  new.updated_at = now();
+  return new;
+end;
+$$ language plpgsql;
+
+create trigger update_user_memories_updated_at
+  before update on public.user_memories
+  for each row
+  execute function update_updated_at_column();
diff --git a/supabase/migrations/20250102000000_schema.sql b/supabase/migrations/20250102000000_schema.sql
deleted file mode 100644
index 6b99092..0000000
--- a/supabase/migrations/20250102000000_schema.sql
+++ /dev/null
@@ -1,62 +0,0 @@
--- Inworld Language Tutor - Supabase Schema
--- Run this in your Supabase SQL Editor to set up the database
-
--- User preferences (language preference)
-create table public.user_preferences (
-  id uuid primary key default gen_random_uuid(),
-  user_id uuid references auth.users(id) on delete cascade not null unique,
-  language_code text default 'es' not null,
-  created_at timestamptz default now() not null,
-  updated_at timestamptz default now() not null
-);
-
--- Conversations (multi-conversation support, per language)
-create table public.conversations (
-  id uuid primary key default gen_random_uuid(),
-  user_id uuid references auth.users(id) on delete cascade not null,
-  language_code text not null,
-  title text not null,
-  created_at timestamptz default now() not null,
-  updated_at timestamptz default now() not null
-);
-
--- Conversation messages (belong to a conversation)
-create table public.conversation_messages (
-  id uuid primary key default gen_random_uuid(),
-  conversation_id uuid references public.conversations(id) on delete cascade not null,
-  role text check (role in ('user', 'assistant')) not null,
-  content text not null,
-  created_at timestamptz default now() not null
-);
-
--- Flashcards (per user per conversation)
-create table public.flashcards (
-  id uuid primary key default gen_random_uuid(),
-  user_id uuid references auth.users(id) on delete cascade not null,
-  language_code text not null,
-  conversation_id uuid references public.conversations(id) on delete cascade,
-  target_word text not null,
-  english text not null,
-  example text,
-  mnemonic text,
-  created_at timestamptz default now() not null,
-  unique(user_id, conversation_id, target_word)
-);
-
--- Indexes
-create index idx_conversations_user_lang on public.conversations(user_id, language_code, updated_at desc);
-create index idx_messages_conversation on public.conversation_messages(conversation_id, created_at);
-create index idx_flashcards_conversation on public.flashcards(user_id, conversation_id);
-
--- Enable Row Level Security
-alter table public.user_preferences enable row level security;
-alter table public.conversations enable row level security;
-alter table public.conversation_messages enable row level security;
-alter table public.flashcards enable row level security;
-
--- RLS Policies (users can only access their own data)
-create policy "Users manage own preferences" on public.user_preferences for all using (auth.uid() = user_id);
-create policy "Users manage own conversations" on public.conversations for all using (auth.uid() = user_id);
-create policy "Users manage own messages" on public.conversation_messages for all
-  using (conversation_id in (select id from public.conversations where user_id = auth.uid()));
-create policy "Users manage own flashcards" on public.flashcards for all using (auth.uid() = user_id);
diff --git a/supabase/migrations/20250106000000_memories.sql b/supabase/migrations/20250106000000_memories.sql
deleted file mode 100644
index 5ff0f90..0000000
--- a/supabase/migrations/20250106000000_memories.sql
+++ /dev/null
@@ -1,88 +0,0 @@
--- Memory System Migration
--- Adds user_memories table with pgvector for semantic memory retrieval
-
--- Enable pgvector extension for vector similarity search
-create extension if not exists vector;
-
--- User memories table (English only)
-create table public.user_memories (
-  id uuid primary key default gen_random_uuid(),
-  user_id uuid references auth.users(id) on delete cascade not null,
-
-  -- Memory content (English)
-  content text not null,
-
-  -- Metadata
-  memory_type text check (memory_type in ('learning_progress', 'personal_context')) not null,
-  topics text[] default '{}',
-  importance float default 0.5,
-
-  -- Embedding (1024 dim for BAAI/bge-large-en-v1.5)
-  embedding vector(1024),
-
-  -- Timestamps
-  created_at timestamptz default now() not null,
-  updated_at timestamptz default now() not null
-);
-
--- Index for vector similarity search using IVFFlat
--- lists = 100 is a reasonable default; adjust based on table size
-create index idx_memories_embedding on public.user_memories
-  using ivfflat (embedding vector_cosine_ops) with (lists = 100);
-
--- Index for user-based queries
-create index idx_memories_user on public.user_memories(user_id, created_at desc);
-
--- Enable Row Level Security
-alter table public.user_memories enable row level security;
-
--- RLS Policy: Users can only manage their own memories
--- Note: Service role key bypasses RLS, which is what the backend uses
-create policy "Users manage own memories" on public.user_memories
-  for all using (auth.uid() = user_id);
-
--- Function to search memories by cosine similarity
-create or replace function match_memories(
-  query_embedding vector(1024),
-  match_user_id uuid,
-  match_threshold float default 0.7,
-  match_count int default 3
-)
-returns table (
-  id uuid,
-  content text,
-  memory_type text,
-  topics text[],
-  importance float,
-  similarity float
-)
-language sql stable
-as $$
-  select
-    user_memories.id,
-    user_memories.content,
-    user_memories.memory_type,
-    user_memories.topics,
-    user_memories.importance,
-    1 - (user_memories.embedding <=> query_embedding) as similarity
-  from user_memories
-  where user_memories.user_id = match_user_id
-    and user_memories.embedding is not null
-    and 1 - (user_memories.embedding <=> query_embedding) > match_threshold
-  order by user_memories.embedding <=> query_embedding
-  limit match_count;
-$$;
-
--- Trigger to update updated_at timestamp
-create or replace function update_updated_at_column()
-returns trigger as $$
-begin
-  new.updated_at = now();
-  return new;
-end;
-$$ language plpgsql;
-
-create trigger update_user_memories_updated_at
-  before update on public.user_memories
-  for each row
-  execute function update_updated_at_column();

From e30a24466d5bc7dfb4aa7b5b0632903bd27da0c8 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 7 Jan 2026 15:30:11 -0800
Subject: [PATCH 31/49] linter updates

---
 README.md                                     | 21 ++++++++++---------
 .../configs/flashcard-generation-graph.json   | 10 +++------
 .../lang-learning-conversation-graph.json     | 10 +++------
 .../configs/response-feedback-graph.json      | 10 +++------
 4 files changed, 20 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 6a1ce9f..1a52eaa 100644
--- a/README.md
+++ b/README.md
@@ -148,6 +148,7 @@ When Supabase is configured, the app stores and retrieves user memories using se
 - **Personalized responses**: The AI uses retrieved memories to personalize conversations
 
 Memory types:
+
 - `learning_progress`: Vocabulary struggles, grammar patterns, learning achievements
 - `personal_context`: Interests, goals, preferences shared by the user
 
@@ -155,16 +156,16 @@ Without Supabase, the app works in anonymous mode using localStorage (no memory
 
 ## Environment Variables Reference
 
-| Variable                     | Required | Description                                                        |
-| ---------------------------- | -------- | ------------------------------------------------------------------ |
-| `INWORLD_API_KEY`            | Yes      | Inworld AI Base64 API key                                          |
-| `ASSEMBLY_AI_API_KEY`        | Yes      | AssemblyAI API key                                                 |
-| `PORT`                       | No       | Server port (default: 3000)                                        |
-| `LOG_LEVEL`                  | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
-| `NODE_ENV`                   | No       | `development` or `production`                                      |
-| `ASSEMBLY_AI_EAGERNESS`      | No       | Turn detection: `low`, `medium`, `high` (default: high)            |
-| `SUPABASE_URL`               | No       | Supabase project URL (enables memory feature)                      |
-| `SUPABASE_SERVICE_ROLE_KEY`  | No       | Supabase service role key (for backend memory storage)             |
+| Variable                    | Required | Description                                                        |
+| --------------------------- | -------- | ------------------------------------------------------------------ |
+| `INWORLD_API_KEY`           | Yes      | Inworld AI Base64 API key                                          |
+| `ASSEMBLY_AI_API_KEY`       | Yes      | AssemblyAI API key                                                 |
+| `PORT`                      | No       | Server port (default: 3000)                                        |
+| `LOG_LEVEL`                 | No       | `trace`, `debug`, `info`, `warn`, `error`, `fatal` (default: info) |
+| `NODE_ENV`                  | No       | `development` or `production`                                      |
+| `ASSEMBLY_AI_EAGERNESS`     | No       | Turn detection: `low`, `medium`, `high` (default: high)            |
+| `SUPABASE_URL`              | No       | Supabase project URL (enables memory feature)                      |
+| `SUPABASE_SERVICE_ROLE_KEY` | No       | Supabase service role key (for backend memory storage)             |
 
 ## Testing
 
diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/graphs/configs/flashcard-generation-graph.json
index 7cb5d7b..a73589e 100644
--- a/backend/graphs/configs/flashcard-generation-graph.json
+++ b/backend/graphs/configs/flashcard-generation-graph.json
@@ -70,12 +70,8 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": [
-      "flashcard-parser"
-    ],
-    "start_nodes": [
-      "flashcard-prompt-builder"
-    ]
+    "end_nodes": ["flashcard-parser"],
+    "start_nodes": ["flashcard-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
index 4c34e49..311da8f 100644
--- a/backend/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -233,12 +233,8 @@
         "loop": true
       }
     ],
-    "end_nodes": [
-      "tts-node-lang-learning"
-    ],
-    "start_nodes": [
-      "audio-input-proxy-lang-learning"
-    ]
+    "end_nodes": ["tts-node-lang-learning"],
+    "start_nodes": ["audio-input-proxy-lang-learning"]
   },
   "components": [
     {
@@ -290,4 +286,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/graphs/configs/response-feedback-graph.json
index 978b019..d694a2b 100644
--- a/backend/graphs/configs/response-feedback-graph.json
+++ b/backend/graphs/configs/response-feedback-graph.json
@@ -70,12 +70,8 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": [
-      "feedback-extractor"
-    ],
-    "start_nodes": [
-      "feedback-prompt-builder"
-    ]
+    "end_nodes": ["feedback-extractor"],
+    "start_nodes": ["feedback-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}

From 855576c8dc8c76ad4ea68c2fd202d3d7716dfdce Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Wed, 7 Jan 2026 15:44:52 -0800
Subject: [PATCH 32/49] fixed left nav scrolling when you have a lot of chats

---
 frontend/src/styles/main.css | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 70835e3..ad4e431 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -25,7 +25,8 @@ body {
 .app-wrapper {
     display: flex;
     flex-direction: column;
-    min-height: 100vh;
+    height: 100vh;
+    overflow: hidden;
 }
 
 .app-layout {

From d8424f20c9a55bc308a3fddeaf4fe18f5e43e634 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 10:40:47 -0800
Subject: [PATCH 33/49] Added start command to frontend

---
 .../configs/flashcard-generation-graph.json   |  10 +-
 .../lang-learning-conversation-graph.json     |  10 +-
 .../configs/response-feedback-graph.json      |  10 +-
 frontend/package-lock.json                    |  15 ++
 frontend/package.json                         |   1 +
 package-lock.json                             | 142 +++++++++++++-----
 6 files changed, 141 insertions(+), 47 deletions(-)

diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/graphs/configs/flashcard-generation-graph.json
index a73589e..7cb5d7b 100644
--- a/backend/graphs/configs/flashcard-generation-graph.json
+++ b/backend/graphs/configs/flashcard-generation-graph.json
@@ -70,8 +70,12 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": ["flashcard-parser"],
-    "start_nodes": ["flashcard-prompt-builder"]
+    "end_nodes": [
+      "flashcard-parser"
+    ],
+    "start_nodes": [
+      "flashcard-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/graphs/configs/lang-learning-conversation-graph.json
index 311da8f..4c34e49 100644
--- a/backend/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/graphs/configs/lang-learning-conversation-graph.json
@@ -233,8 +233,12 @@
         "loop": true
       }
     ],
-    "end_nodes": ["tts-node-lang-learning"],
-    "start_nodes": ["audio-input-proxy-lang-learning"]
+    "end_nodes": [
+      "tts-node-lang-learning"
+    ],
+    "start_nodes": [
+      "audio-input-proxy-lang-learning"
+    ]
   },
   "components": [
     {
@@ -286,4 +290,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/graphs/configs/response-feedback-graph.json
index d694a2b..978b019 100644
--- a/backend/graphs/configs/response-feedback-graph.json
+++ b/backend/graphs/configs/response-feedback-graph.json
@@ -70,8 +70,12 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": ["feedback-extractor"],
-    "start_nodes": ["feedback-prompt-builder"]
+    "end_nodes": [
+      "feedback-extractor"
+    ],
+    "start_nodes": [
+      "feedback-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 295597c..e697c60 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -81,6 +81,7 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -420,6 +421,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -443,6 +445,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1623,6 +1626,7 @@
       "integrity": "sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1691,6 +1695,7 @@
       "integrity": "sha512-3xP4XzzDNQOIqBMWogftkwxhg5oMKApqY0BAflmLZiFYHqyhSOxv/cd/zPQLTcCXr4AkaKb25joocY0BD1WC6A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.51.0",
         "@typescript-eslint/types": "8.51.0",
@@ -2028,6 +2033,7 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2160,6 +2166,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -2591,6 +2598,7 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -3241,6 +3249,7 @@
       "integrity": "sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssstyle": "^4.1.0",
         "data-urls": "^5.0.0",
@@ -3616,6 +3625,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -3677,6 +3687,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
       "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -4030,6 +4041,7 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -4115,6 +4127,7 @@
       "integrity": "sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.27.0",
         "fdir": "^6.5.0",
@@ -5226,6 +5239,7 @@
       "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",
@@ -5448,6 +5462,7 @@
       "integrity": "sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
diff --git a/frontend/package.json b/frontend/package.json
index 12b6841..0f7c1ea 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc -b && vite build",
+    "start": "vite preview",
     "lint": "eslint .",
     "preview": "vite preview",
     "test": "vitest run",
diff --git a/package-lock.json b/package-lock.json
index 5ef5977..abfd5a1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1689,6 +1689,7 @@
       "integrity": "sha512-tK3GPFWbirvNgsNKto+UmB/cRtn6TZfyw0D6IKrW55n6Vbs7KJoZtI//kpTKzE/DUmmnAFD8/Ca46s7Obs92/w==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.46.4",
         "@typescript-eslint/types": "8.46.4",
@@ -2212,6 +2213,7 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2468,29 +2470,58 @@
       }
     },
     "node_modules/body-parser": {
-      "version": "1.20.3",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
-      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "version": "1.20.4",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz",
+      "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==",
       "license": "MIT",
       "dependencies": {
-        "bytes": "3.1.2",
+        "bytes": "~3.1.2",
         "content-type": "~1.0.5",
         "debug": "2.6.9",
         "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "on-finished": "2.4.1",
-        "qs": "6.13.0",
-        "raw-body": "2.5.2",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.14.0",
+        "raw-body": "~2.5.3",
         "type-is": "~1.6.18",
-        "unpipe": "1.0.0"
+        "unpipe": "~1.0.0"
       },
       "engines": {
         "node": ">= 0.8",
         "npm": "1.2.8000 || >= 1.4.16"
       }
     },
+    "node_modules/body-parser/node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/body-parser/node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.12",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
@@ -3278,6 +3309,7 @@
       "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -3338,6 +3370,7 @@
       "integrity": "sha512-iI1f+D2ViGn+uvv5HuHVUamg8ll4tN+JRHGc6IJi4TP9Kl976C57fzPXgseXNs8v0iA8aSJpHsTWjDb9QJamGQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -3571,39 +3604,39 @@
       }
     },
     "node_modules/express": {
-      "version": "4.21.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
-      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "version": "4.22.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
+      "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
       "license": "MIT",
       "dependencies": {
         "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "1.20.3",
-        "content-disposition": "0.5.4",
+        "body-parser": "~1.20.3",
+        "content-disposition": "~0.5.4",
         "content-type": "~1.0.4",
-        "cookie": "0.7.1",
-        "cookie-signature": "1.0.6",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
         "debug": "2.6.9",
         "depd": "2.0.0",
         "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "finalhandler": "1.3.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
         "merge-descriptors": "1.0.3",
         "methods": "~1.1.2",
-        "on-finished": "2.4.1",
+        "on-finished": "~2.4.1",
         "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.12",
+        "path-to-regexp": "~0.1.12",
         "proxy-addr": "~2.0.7",
-        "qs": "6.13.0",
+        "qs": "~6.14.0",
         "range-parser": "~1.2.1",
         "safe-buffer": "5.2.1",
-        "send": "0.19.0",
-        "serve-static": "1.16.2",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
         "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
+        "statuses": "~2.0.1",
         "type-is": "~1.6.18",
         "utils-merge": "1.0.1",
         "vary": "~1.1.2"
@@ -5517,6 +5550,7 @@
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -5638,12 +5672,12 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
-      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "version": "6.14.1",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
+      "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.0.6"
+        "side-channel": "^1.1.0"
       },
       "engines": {
         "node": ">=0.6"
@@ -5689,20 +5723,49 @@
       }
     },
     "node_modules/raw-body": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
-      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "version": "2.5.3",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
       "license": "MIT",
       "dependencies": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "unpipe": "1.0.0"
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
       },
       "engines": {
         "node": ">= 0.8"
       }
     },
+    "node_modules/raw-body/node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/raw-body/node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/read-cmd-shim": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-6.0.0.tgz",
@@ -6708,6 +6771,7 @@
       "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -6825,6 +6889,7 @@
       "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",
@@ -7363,6 +7428,7 @@
       "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/expect": "2.1.9",
         "@vitest/mocker": "2.1.9",

From b41ff12547dcdda7c5df914d3df6b38a86686379 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 11:07:32 -0800
Subject: [PATCH 34/49] Restructured files, decoupled frontend and backend,
 aligned configuration

---
 .prettierrc.json                              |  1 +
 .../eslint.config.mjs                         |  0
 .../package-lock.json                         |  0
 package.json => backend/package.json          | 16 ++---
 .../__tests__/config/languages.test.ts        |  0
 .../__tests__/helpers/anki-exporter.test.ts   |  0
 .../__tests__/helpers/audio-utils.test.ts     |  0
 backend/{ => src}/config/embedder.ts          |  0
 backend/{ => src}/config/languages.ts         |  0
 backend/{ => src}/config/llm.ts               |  0
 backend/{ => src}/config/server.ts            |  1 +
 backend/{ => src}/config/supabase.ts          |  0
 .../configs/flashcard-generation-graph.json   |  0
 .../lang-learning-conversation-graph.json     |  0
 .../configs/response-feedback-graph.json      |  0
 .../{ => src}/graphs/conversation-graph.ts    |  0
 backend/{ => src}/graphs/flashcard-graph.ts   |  0
 .../graphs/memory-generation-graph.ts         |  0
 .../graphs/nodes/assembly-ai-stt-ws-node.ts   |  0
 .../nodes/dialog-prompt-builder-node.ts       |  0
 .../graphs/nodes/interaction-queue-node.ts    |  0
 .../nodes/memory-prompt-builder-node.ts       |  0
 .../graphs/nodes/memory-retrieval-node.ts     |  0
 .../graphs/nodes/state-update-node.ts         |  0
 .../{ => src}/graphs/nodes/text-input-node.ts |  0
 .../graphs/nodes/transcript-extractor-node.ts |  0
 .../graphs/nodes/tts-request-builder-node.ts  |  0
 .../graphs/response-feedback-graph.ts         |  0
 backend/{ => src}/graphs/simple-tts-graph.ts  |  0
 backend/{ => src}/helpers/anki-exporter.ts    |  0
 backend/{ => src}/helpers/audio-buffer.ts     |  0
 backend/{ => src}/helpers/audio-utils.ts      |  0
 .../{ => src}/helpers/connection-manager.ts   |  0
 .../{ => src}/helpers/feedback-processor.ts   |  0
 .../{ => src}/helpers/flashcard-processor.ts  |  0
 backend/{ => src}/helpers/memory-processor.ts |  0
 .../helpers/multimodal-stream-manager.ts      |  0
 backend/{ => src}/helpers/prompt-templates.ts |  0
 backend/{ => src}/prompts/conversation.njk    |  0
 backend/{ => src}/prompts/flashcard.njk       |  0
 .../{ => src}/prompts/memory-generation.njk   |  0
 .../{ => src}/prompts/response-feedback.njk   |  0
 backend/{ => src}/server.ts                   | 14 -----
 backend/{ => src}/services/api-routes.ts      |  0
 backend/{ => src}/services/graph-service.ts   |  0
 backend/{ => src}/services/memory-service.ts  |  0
 backend/{ => src}/services/shutdown.ts        |  0
 backend/{ => src}/services/state.ts           |  0
 backend/{ => src}/services/telemetry.ts       |  0
 .../{ => src}/services/websocket-handler.ts   |  0
 backend/{ => src}/types/index.ts              |  0
 backend/{ => src}/types/memory.ts             |  0
 backend/{ => src}/utils/logger.ts             |  0
 backend/tsconfig.eslint.json                  |  5 ++
 tsconfig.json => backend/tsconfig.json        | 10 ++--
 backend/vitest.config.ts                      |  4 +-
 frontend/eslint.config.js                     | 23 --------
 frontend/eslint.config.mjs                    | 58 +++++++++++++++++++
 frontend/package.json                         |  6 ++
 frontend/tsconfig.app.json                    | 35 -----------
 frontend/tsconfig.eslint.json                 |  5 ++
 frontend/tsconfig.json                        | 36 ++++++++++--
 frontend/tsconfig.node.json                   | 26 ---------
 tsconfig.eslint.json                          |  5 --
 64 files changed, 122 insertions(+), 123 deletions(-)
 rename eslint.config.mjs => backend/eslint.config.mjs (100%)
 rename package-lock.json => backend/package-lock.json (100%)
 rename package.json => backend/package.json (79%)
 rename backend/{ => src}/__tests__/config/languages.test.ts (100%)
 rename backend/{ => src}/__tests__/helpers/anki-exporter.test.ts (100%)
 rename backend/{ => src}/__tests__/helpers/audio-utils.test.ts (100%)
 rename backend/{ => src}/config/embedder.ts (100%)
 rename backend/{ => src}/config/languages.ts (100%)
 rename backend/{ => src}/config/llm.ts (100%)
 rename backend/{ => src}/config/server.ts (99%)
 rename backend/{ => src}/config/supabase.ts (100%)
 rename backend/{ => src}/graphs/configs/flashcard-generation-graph.json (100%)
 rename backend/{ => src}/graphs/configs/lang-learning-conversation-graph.json (100%)
 rename backend/{ => src}/graphs/configs/response-feedback-graph.json (100%)
 rename backend/{ => src}/graphs/conversation-graph.ts (100%)
 rename backend/{ => src}/graphs/flashcard-graph.ts (100%)
 rename backend/{ => src}/graphs/memory-generation-graph.ts (100%)
 rename backend/{ => src}/graphs/nodes/assembly-ai-stt-ws-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/dialog-prompt-builder-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/interaction-queue-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/memory-prompt-builder-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/memory-retrieval-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/state-update-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/text-input-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/transcript-extractor-node.ts (100%)
 rename backend/{ => src}/graphs/nodes/tts-request-builder-node.ts (100%)
 rename backend/{ => src}/graphs/response-feedback-graph.ts (100%)
 rename backend/{ => src}/graphs/simple-tts-graph.ts (100%)
 rename backend/{ => src}/helpers/anki-exporter.ts (100%)
 rename backend/{ => src}/helpers/audio-buffer.ts (100%)
 rename backend/{ => src}/helpers/audio-utils.ts (100%)
 rename backend/{ => src}/helpers/connection-manager.ts (100%)
 rename backend/{ => src}/helpers/feedback-processor.ts (100%)
 rename backend/{ => src}/helpers/flashcard-processor.ts (100%)
 rename backend/{ => src}/helpers/memory-processor.ts (100%)
 rename backend/{ => src}/helpers/multimodal-stream-manager.ts (100%)
 rename backend/{ => src}/helpers/prompt-templates.ts (100%)
 rename backend/{ => src}/prompts/conversation.njk (100%)
 rename backend/{ => src}/prompts/flashcard.njk (100%)
 rename backend/{ => src}/prompts/memory-generation.njk (100%)
 rename backend/{ => src}/prompts/response-feedback.njk (100%)
 rename backend/{ => src}/server.ts (80%)
 rename backend/{ => src}/services/api-routes.ts (100%)
 rename backend/{ => src}/services/graph-service.ts (100%)
 rename backend/{ => src}/services/memory-service.ts (100%)
 rename backend/{ => src}/services/shutdown.ts (100%)
 rename backend/{ => src}/services/state.ts (100%)
 rename backend/{ => src}/services/telemetry.ts (100%)
 rename backend/{ => src}/services/websocket-handler.ts (100%)
 rename backend/{ => src}/types/index.ts (100%)
 rename backend/{ => src}/types/memory.ts (100%)
 rename backend/{ => src}/utils/logger.ts (100%)
 create mode 100644 backend/tsconfig.eslint.json
 rename tsconfig.json => backend/tsconfig.json (84%)
 delete mode 100644 frontend/eslint.config.js
 create mode 100644 frontend/eslint.config.mjs
 delete mode 100644 frontend/tsconfig.app.json
 create mode 100644 frontend/tsconfig.eslint.json
 delete mode 100644 frontend/tsconfig.node.json
 delete mode 100644 tsconfig.eslint.json

diff --git a/.prettierrc.json b/.prettierrc.json
index 3171de5..63d982b 100644
--- a/.prettierrc.json
+++ b/.prettierrc.json
@@ -8,3 +8,4 @@
   "arrowParens": "always",
   "endOfLine": "lf"
 }
+
diff --git a/eslint.config.mjs b/backend/eslint.config.mjs
similarity index 100%
rename from eslint.config.mjs
rename to backend/eslint.config.mjs
diff --git a/package-lock.json b/backend/package-lock.json
similarity index 100%
rename from package-lock.json
rename to backend/package-lock.json
diff --git a/package.json b/backend/package.json
similarity index 79%
rename from package.json
rename to backend/package.json
index 827d222..dc5d505 100644
--- a/package.json
+++ b/backend/package.json
@@ -1,17 +1,17 @@
 {
   "name": "language-learning",
   "version": "1.0.0",
-  "main": "dist/backend/server.js",
+  "main": "dist/server.js",
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/backend/server.js",
-    "dev": "nodemon --exec \"tsx backend/server.ts\" --ext ts",
-    "test-stt": "tsx backend/test-stt.ts",
+    "build": "tsc && cp -r src/prompts dist/prompts",
+    "start": "node dist/server.js",
+    "dev": "nodemon --exec \"tsx src/server.ts\" --ext ts",
+    "test-stt": "tsx test-stt.ts",
     "test": "npm run test:backend && npm run test:frontend",
-    "test:backend": "vitest run --config backend/vitest.config.ts",
-    "test:frontend": "npm run test --prefix frontend",
-    "test:watch": "vitest --config backend/vitest.config.ts",
+    "test:backend": "vitest run --config vitest.config.ts",
+    "test:frontend": "npm run test --prefix ../frontend",
+    "test:watch": "vitest --config vitest.config.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
diff --git a/backend/__tests__/config/languages.test.ts b/backend/src/__tests__/config/languages.test.ts
similarity index 100%
rename from backend/__tests__/config/languages.test.ts
rename to backend/src/__tests__/config/languages.test.ts
diff --git a/backend/__tests__/helpers/anki-exporter.test.ts b/backend/src/__tests__/helpers/anki-exporter.test.ts
similarity index 100%
rename from backend/__tests__/helpers/anki-exporter.test.ts
rename to backend/src/__tests__/helpers/anki-exporter.test.ts
diff --git a/backend/__tests__/helpers/audio-utils.test.ts b/backend/src/__tests__/helpers/audio-utils.test.ts
similarity index 100%
rename from backend/__tests__/helpers/audio-utils.test.ts
rename to backend/src/__tests__/helpers/audio-utils.test.ts
diff --git a/backend/config/embedder.ts b/backend/src/config/embedder.ts
similarity index 100%
rename from backend/config/embedder.ts
rename to backend/src/config/embedder.ts
diff --git a/backend/config/languages.ts b/backend/src/config/languages.ts
similarity index 100%
rename from backend/config/languages.ts
rename to backend/src/config/languages.ts
diff --git a/backend/config/llm.ts b/backend/src/config/llm.ts
similarity index 100%
rename from backend/config/llm.ts
rename to backend/src/config/llm.ts
diff --git a/backend/config/server.ts b/backend/src/config/server.ts
similarity index 99%
rename from backend/config/server.ts
rename to backend/src/config/server.ts
index aa6f9ac..8ed8338 100644
--- a/backend/config/server.ts
+++ b/backend/src/config/server.ts
@@ -111,3 +111,4 @@ export function getAssemblyAISettingsForEagerness(
 ): AssemblyAITurnDetectionSettings {
   return assemblyAIPresets[eagerness];
 }
+
diff --git a/backend/config/supabase.ts b/backend/src/config/supabase.ts
similarity index 100%
rename from backend/config/supabase.ts
rename to backend/src/config/supabase.ts
diff --git a/backend/graphs/configs/flashcard-generation-graph.json b/backend/src/graphs/configs/flashcard-generation-graph.json
similarity index 100%
rename from backend/graphs/configs/flashcard-generation-graph.json
rename to backend/src/graphs/configs/flashcard-generation-graph.json
diff --git a/backend/graphs/configs/lang-learning-conversation-graph.json b/backend/src/graphs/configs/lang-learning-conversation-graph.json
similarity index 100%
rename from backend/graphs/configs/lang-learning-conversation-graph.json
rename to backend/src/graphs/configs/lang-learning-conversation-graph.json
diff --git a/backend/graphs/configs/response-feedback-graph.json b/backend/src/graphs/configs/response-feedback-graph.json
similarity index 100%
rename from backend/graphs/configs/response-feedback-graph.json
rename to backend/src/graphs/configs/response-feedback-graph.json
diff --git a/backend/graphs/conversation-graph.ts b/backend/src/graphs/conversation-graph.ts
similarity index 100%
rename from backend/graphs/conversation-graph.ts
rename to backend/src/graphs/conversation-graph.ts
diff --git a/backend/graphs/flashcard-graph.ts b/backend/src/graphs/flashcard-graph.ts
similarity index 100%
rename from backend/graphs/flashcard-graph.ts
rename to backend/src/graphs/flashcard-graph.ts
diff --git a/backend/graphs/memory-generation-graph.ts b/backend/src/graphs/memory-generation-graph.ts
similarity index 100%
rename from backend/graphs/memory-generation-graph.ts
rename to backend/src/graphs/memory-generation-graph.ts
diff --git a/backend/graphs/nodes/assembly-ai-stt-ws-node.ts b/backend/src/graphs/nodes/assembly-ai-stt-ws-node.ts
similarity index 100%
rename from backend/graphs/nodes/assembly-ai-stt-ws-node.ts
rename to backend/src/graphs/nodes/assembly-ai-stt-ws-node.ts
diff --git a/backend/graphs/nodes/dialog-prompt-builder-node.ts b/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
similarity index 100%
rename from backend/graphs/nodes/dialog-prompt-builder-node.ts
rename to backend/src/graphs/nodes/dialog-prompt-builder-node.ts
diff --git a/backend/graphs/nodes/interaction-queue-node.ts b/backend/src/graphs/nodes/interaction-queue-node.ts
similarity index 100%
rename from backend/graphs/nodes/interaction-queue-node.ts
rename to backend/src/graphs/nodes/interaction-queue-node.ts
diff --git a/backend/graphs/nodes/memory-prompt-builder-node.ts b/backend/src/graphs/nodes/memory-prompt-builder-node.ts
similarity index 100%
rename from backend/graphs/nodes/memory-prompt-builder-node.ts
rename to backend/src/graphs/nodes/memory-prompt-builder-node.ts
diff --git a/backend/graphs/nodes/memory-retrieval-node.ts b/backend/src/graphs/nodes/memory-retrieval-node.ts
similarity index 100%
rename from backend/graphs/nodes/memory-retrieval-node.ts
rename to backend/src/graphs/nodes/memory-retrieval-node.ts
diff --git a/backend/graphs/nodes/state-update-node.ts b/backend/src/graphs/nodes/state-update-node.ts
similarity index 100%
rename from backend/graphs/nodes/state-update-node.ts
rename to backend/src/graphs/nodes/state-update-node.ts
diff --git a/backend/graphs/nodes/text-input-node.ts b/backend/src/graphs/nodes/text-input-node.ts
similarity index 100%
rename from backend/graphs/nodes/text-input-node.ts
rename to backend/src/graphs/nodes/text-input-node.ts
diff --git a/backend/graphs/nodes/transcript-extractor-node.ts b/backend/src/graphs/nodes/transcript-extractor-node.ts
similarity index 100%
rename from backend/graphs/nodes/transcript-extractor-node.ts
rename to backend/src/graphs/nodes/transcript-extractor-node.ts
diff --git a/backend/graphs/nodes/tts-request-builder-node.ts b/backend/src/graphs/nodes/tts-request-builder-node.ts
similarity index 100%
rename from backend/graphs/nodes/tts-request-builder-node.ts
rename to backend/src/graphs/nodes/tts-request-builder-node.ts
diff --git a/backend/graphs/response-feedback-graph.ts b/backend/src/graphs/response-feedback-graph.ts
similarity index 100%
rename from backend/graphs/response-feedback-graph.ts
rename to backend/src/graphs/response-feedback-graph.ts
diff --git a/backend/graphs/simple-tts-graph.ts b/backend/src/graphs/simple-tts-graph.ts
similarity index 100%
rename from backend/graphs/simple-tts-graph.ts
rename to backend/src/graphs/simple-tts-graph.ts
diff --git a/backend/helpers/anki-exporter.ts b/backend/src/helpers/anki-exporter.ts
similarity index 100%
rename from backend/helpers/anki-exporter.ts
rename to backend/src/helpers/anki-exporter.ts
diff --git a/backend/helpers/audio-buffer.ts b/backend/src/helpers/audio-buffer.ts
similarity index 100%
rename from backend/helpers/audio-buffer.ts
rename to backend/src/helpers/audio-buffer.ts
diff --git a/backend/helpers/audio-utils.ts b/backend/src/helpers/audio-utils.ts
similarity index 100%
rename from backend/helpers/audio-utils.ts
rename to backend/src/helpers/audio-utils.ts
diff --git a/backend/helpers/connection-manager.ts b/backend/src/helpers/connection-manager.ts
similarity index 100%
rename from backend/helpers/connection-manager.ts
rename to backend/src/helpers/connection-manager.ts
diff --git a/backend/helpers/feedback-processor.ts b/backend/src/helpers/feedback-processor.ts
similarity index 100%
rename from backend/helpers/feedback-processor.ts
rename to backend/src/helpers/feedback-processor.ts
diff --git a/backend/helpers/flashcard-processor.ts b/backend/src/helpers/flashcard-processor.ts
similarity index 100%
rename from backend/helpers/flashcard-processor.ts
rename to backend/src/helpers/flashcard-processor.ts
diff --git a/backend/helpers/memory-processor.ts b/backend/src/helpers/memory-processor.ts
similarity index 100%
rename from backend/helpers/memory-processor.ts
rename to backend/src/helpers/memory-processor.ts
diff --git a/backend/helpers/multimodal-stream-manager.ts b/backend/src/helpers/multimodal-stream-manager.ts
similarity index 100%
rename from backend/helpers/multimodal-stream-manager.ts
rename to backend/src/helpers/multimodal-stream-manager.ts
diff --git a/backend/helpers/prompt-templates.ts b/backend/src/helpers/prompt-templates.ts
similarity index 100%
rename from backend/helpers/prompt-templates.ts
rename to backend/src/helpers/prompt-templates.ts
diff --git a/backend/prompts/conversation.njk b/backend/src/prompts/conversation.njk
similarity index 100%
rename from backend/prompts/conversation.njk
rename to backend/src/prompts/conversation.njk
diff --git a/backend/prompts/flashcard.njk b/backend/src/prompts/flashcard.njk
similarity index 100%
rename from backend/prompts/flashcard.njk
rename to backend/src/prompts/flashcard.njk
diff --git a/backend/prompts/memory-generation.njk b/backend/src/prompts/memory-generation.njk
similarity index 100%
rename from backend/prompts/memory-generation.njk
rename to backend/src/prompts/memory-generation.njk
diff --git a/backend/prompts/response-feedback.njk b/backend/src/prompts/response-feedback.njk
similarity index 100%
rename from backend/prompts/response-feedback.njk
rename to backend/src/prompts/response-feedback.njk
diff --git a/backend/server.ts b/backend/src/server.ts
similarity index 80%
rename from backend/server.ts
rename to backend/src/server.ts
index c46b48f..4e970b9 100644
--- a/backend/server.ts
+++ b/backend/src/server.ts
@@ -12,9 +12,6 @@
 import dotenv from 'dotenv';
 dotenv.config();
 
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { existsSync } from 'fs';
 import express from 'express';
 import cors from 'cors';
 import { createServer } from 'http';
@@ -33,9 +30,6 @@ import { setupWebSocketHandlers } from './services/websocket-handler.js';
 import { apiRouter } from './services/api-routes.js';
 import { createGracefulShutdown } from './services/shutdown.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
 // Initialize Express and servers
 const app = express();
 const server = createServer(app);
@@ -62,14 +56,6 @@ app.get('/health', (_req, res) => {
     .json({ status: 'healthy', timestamp: new Date().toISOString() });
 });
 
-// Static files
-const frontendPath = path.join(__dirname, '../../frontend');
-const devFrontendPath = path.join(__dirname, '../frontend');
-const staticPath = path.resolve(frontendPath);
-const devStaticPath = path.resolve(devFrontendPath);
-const finalStaticPath = existsSync(devStaticPath) ? devStaticPath : staticPath;
-app.use(express.static(finalStaticPath));
-
 // WebSocket handlers
 setupWebSocketHandlers(wss);
 
diff --git a/backend/services/api-routes.ts b/backend/src/services/api-routes.ts
similarity index 100%
rename from backend/services/api-routes.ts
rename to backend/src/services/api-routes.ts
diff --git a/backend/services/graph-service.ts b/backend/src/services/graph-service.ts
similarity index 100%
rename from backend/services/graph-service.ts
rename to backend/src/services/graph-service.ts
diff --git a/backend/services/memory-service.ts b/backend/src/services/memory-service.ts
similarity index 100%
rename from backend/services/memory-service.ts
rename to backend/src/services/memory-service.ts
diff --git a/backend/services/shutdown.ts b/backend/src/services/shutdown.ts
similarity index 100%
rename from backend/services/shutdown.ts
rename to backend/src/services/shutdown.ts
diff --git a/backend/services/state.ts b/backend/src/services/state.ts
similarity index 100%
rename from backend/services/state.ts
rename to backend/src/services/state.ts
diff --git a/backend/services/telemetry.ts b/backend/src/services/telemetry.ts
similarity index 100%
rename from backend/services/telemetry.ts
rename to backend/src/services/telemetry.ts
diff --git a/backend/services/websocket-handler.ts b/backend/src/services/websocket-handler.ts
similarity index 100%
rename from backend/services/websocket-handler.ts
rename to backend/src/services/websocket-handler.ts
diff --git a/backend/types/index.ts b/backend/src/types/index.ts
similarity index 100%
rename from backend/types/index.ts
rename to backend/src/types/index.ts
diff --git a/backend/types/memory.ts b/backend/src/types/memory.ts
similarity index 100%
rename from backend/types/memory.ts
rename to backend/src/types/memory.ts
diff --git a/backend/utils/logger.ts b/backend/src/utils/logger.ts
similarity index 100%
rename from backend/utils/logger.ts
rename to backend/src/utils/logger.ts
diff --git a/backend/tsconfig.eslint.json b/backend/tsconfig.eslint.json
new file mode 100644
index 0000000..631f88a
--- /dev/null
+++ b/backend/tsconfig.eslint.json
@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/tsconfig.json b/backend/tsconfig.json
similarity index 84%
rename from tsconfig.json
rename to backend/tsconfig.json
index beab951..f2ce9ec 100644
--- a/tsconfig.json
+++ b/backend/tsconfig.json
@@ -6,7 +6,7 @@
     "moduleResolution": "bundler",
     "lib": ["ES2022"],
     "outDir": "./dist",
-    "rootDir": "./",
+    "rootDir": "./src",
     "strict": true,
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
@@ -22,13 +22,11 @@
     "noFallthroughCasesInSwitch": true,
     "noEmit": false
   },
-  "include": ["backend/**/*"],
+  "include": ["src/**/*"],
   "exclude": [
     "node_modules",
     "dist",
-    "frontend",
-    "templates/**",
-    "**/*.test.ts",
-    "**/*.spec.ts"
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts"
   ]
 }
diff --git a/backend/vitest.config.ts b/backend/vitest.config.ts
index 3a80879..6b2ae2a 100644
--- a/backend/vitest.config.ts
+++ b/backend/vitest.config.ts
@@ -4,8 +4,8 @@ export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    root: './backend',
-    include: ['__tests__/**/*.test.ts'],
+    root: './',
+    include: ['src/**/*.test.ts'],
     coverage: {
       reporter: ['text', 'lcov'],
       exclude: ['node_modules', '__tests__', 'graphs/nodes/**'],
diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js
deleted file mode 100644
index a53e381..0000000
--- a/frontend/eslint.config.js
+++ /dev/null
@@ -1,23 +0,0 @@
-import js from '@eslint/js';
-import globals from 'globals';
-import reactHooks from 'eslint-plugin-react-hooks';
-import reactRefresh from 'eslint-plugin-react-refresh';
-import tseslint from 'typescript-eslint';
-import { defineConfig, globalIgnores } from 'eslint/config';
-
-export default defineConfig([
-  globalIgnores(['dist']),
-  {
-    files: ['**/*.{ts,tsx}'],
-    extends: [
-      js.configs.recommended,
-      tseslint.configs.recommended,
-      reactHooks.configs.flat.recommended,
-      reactRefresh.configs.vite,
-    ],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: globals.browser,
-    },
-  },
-]);
diff --git a/frontend/eslint.config.mjs b/frontend/eslint.config.mjs
new file mode 100644
index 0000000..3a5802e
--- /dev/null
+++ b/frontend/eslint.config.mjs
@@ -0,0 +1,58 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import prettierConfig from 'eslint-config-prettier';
+import prettierPlugin from 'eslint-plugin-prettier';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import globals from 'globals';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default [
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettierConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    ...tseslint.configs.recommendedTypeChecked[0],
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        project: './tsconfig.eslint.json',
+        tsconfigRootDir: __dirname,
+      },
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      prettier: prettierPlugin,
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      'prettier/prettier': 'error',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+        },
+      ],
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+  {
+    ignores: ['dist/**', 'node_modules/**', '*.js', '*.config.js'],
+  },
+];
+
diff --git a/frontend/package.json b/frontend/package.json
index 0f7c1ea..1fd3274 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -8,6 +8,9 @@
     "build": "tsc -b && vite build",
     "start": "vite preview",
     "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,json,md}\"",
     "preview": "vite preview",
     "test": "vitest run",
     "test:watch": "vitest"
@@ -25,9 +28,12 @@
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.1",
     "eslint": "^9.39.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "prettier": "^3.2.5",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
     "vite": "^7.2.4",
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
deleted file mode 100644
index 5bc40ce..0000000
--- a/frontend/tsconfig.app.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "types": ["vite/client"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["src"],
-  "exclude": [
-    "src/__tests__",
-    "**/*.test.ts",
-    "**/*.test.tsx",
-    "**/*.spec.ts",
-    "**/*.spec.tsx"
-  ]
-}
diff --git a/frontend/tsconfig.eslint.json b/frontend/tsconfig.eslint.json
new file mode 100644
index 0000000..6bdef84
--- /dev/null
+++ b/frontend/tsconfig.eslint.json
@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
index 1ffef60..842b6f8 100644
--- a/frontend/tsconfig.json
+++ b/frontend/tsconfig.json
@@ -1,7 +1,35 @@
 {
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client", "node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src", "vite.config.ts"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "src/__tests__",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx"
   ]
 }
diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json
deleted file mode 100644
index 8a67f62..0000000
--- a/frontend/tsconfig.node.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-    "target": "ES2023",
-    "lib": ["ES2023"],
-    "module": "ESNext",
-    "types": ["node"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["vite.config.ts"]
-}
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
deleted file mode 100644
index ba33b2d..0000000
--- a/tsconfig.eslint.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["backend/**/*"],
-  "exclude": ["node_modules", "dist", "frontend", "templates/**"]
-}

From 046155ed81bf4260eff1cd29ff696dc3079d539a Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 11:09:41 -0800
Subject: [PATCH 35/49] Fixed vulnerabilities

---
 backend/package-lock.json  | 1546 ++++++++++++++----------------------
 backend/package.json       |    4 +-
 frontend/package-lock.json | 1461 +++++++---------------------------
 frontend/package.json      |    4 +-
 4 files changed, 869 insertions(+), 2146 deletions(-)

diff --git a/backend/package-lock.json b/backend/package-lock.json
index abfd5a1..0f6c63d 100644
--- a/backend/package-lock.json
+++ b/backend/package-lock.json
@@ -26,7 +26,7 @@
         "@types/express": "^4.17.21",
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.12",
-        "@vitest/coverage-v8": "^2.1.0",
+        "@vitest/coverage-v8": "^4.0.16",
         "eslint": "^9.0.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-prettier": "^5.1.3",
@@ -37,27 +37,13 @@
         "tsx": "^4.7.0",
         "typescript": "^5.3.3",
         "typescript-eslint": "^8.0.0",
-        "vitest": "^2.1.0"
+        "vitest": "^4.0.16"
       },
       "engines": {
         "node": ">=20.0.0",
         "npm": ">=9.0.0"
       }
     },
-    "node_modules/@ampproject/remapping": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
-      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
     "node_modules/@babel/helper-string-parser": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
@@ -109,11 +95,14 @@
       }
     },
     "node_modules/@bcoe/v8-coverage": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
-      "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+      "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.25.12",
@@ -855,24 +844,6 @@
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/@isaacs/fs-minipass": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
@@ -886,27 +857,6 @@
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@istanbuljs/schema": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",
-      "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
     "node_modules/@jridgewell/resolve-uri": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
@@ -979,17 +929,6 @@
       "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==",
       "license": "MIT"
     },
-    "node_modules/@pkgjs/parseargs": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
-      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=14"
-      }
-    },
     "node_modules/@pkgr/core": {
       "version": "0.2.9",
       "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz",
@@ -1068,9 +1007,9 @@
       "license": "BSD-3-Clause"
     },
     "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.54.0.tgz",
-      "integrity": "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.55.1.tgz",
+      "integrity": "sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==",
       "cpu": [
         "arm"
       ],
@@ -1082,9 +1021,9 @@
       ]
     },
     "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.54.0.tgz",
-      "integrity": "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.55.1.tgz",
+      "integrity": "sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==",
       "cpu": [
         "arm64"
       ],
@@ -1096,9 +1035,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.54.0.tgz",
-      "integrity": "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.55.1.tgz",
+      "integrity": "sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==",
       "cpu": [
         "arm64"
       ],
@@ -1110,9 +1049,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.54.0.tgz",
-      "integrity": "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.55.1.tgz",
+      "integrity": "sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==",
       "cpu": [
         "x64"
       ],
@@ -1124,9 +1063,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.54.0.tgz",
-      "integrity": "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.55.1.tgz",
+      "integrity": "sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==",
       "cpu": [
         "arm64"
       ],
@@ -1138,9 +1077,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.54.0.tgz",
-      "integrity": "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.55.1.tgz",
+      "integrity": "sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==",
       "cpu": [
         "x64"
       ],
@@ -1152,9 +1091,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.54.0.tgz",
-      "integrity": "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.55.1.tgz",
+      "integrity": "sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==",
       "cpu": [
         "arm"
       ],
@@ -1166,9 +1105,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.54.0.tgz",
-      "integrity": "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.55.1.tgz",
+      "integrity": "sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==",
       "cpu": [
         "arm"
       ],
@@ -1180,9 +1119,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.54.0.tgz",
-      "integrity": "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.55.1.tgz",
+      "integrity": "sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==",
       "cpu": [
         "arm64"
       ],
@@ -1194,9 +1133,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.54.0.tgz",
-      "integrity": "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.55.1.tgz",
+      "integrity": "sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==",
       "cpu": [
         "arm64"
       ],
@@ -1208,9 +1147,23 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.54.0.tgz",
-      "integrity": "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.55.1.tgz",
+      "integrity": "sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.55.1.tgz",
+      "integrity": "sha512-MR8c0+UxAlB22Fq4R+aQSPBayvYa3+9DrwG/i1TKQXFYEaoW3B5b/rkSRIypcZDdWjWnpcvxbNaAJDcSbJU3Lw==",
       "cpu": [
         "loong64"
       ],
@@ -1222,9 +1175,23 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.54.0.tgz",
-      "integrity": "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.55.1.tgz",
+      "integrity": "sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.55.1.tgz",
+      "integrity": "sha512-ziR1OuZx0vdYZZ30vueNZTg73alF59DicYrPViG0NEgDVN8/Jl87zkAPu4u6VjZST2llgEUjaiNl9JM6HH1Vdw==",
       "cpu": [
         "ppc64"
       ],
@@ -1236,9 +1203,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.54.0.tgz",
-      "integrity": "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.55.1.tgz",
+      "integrity": "sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==",
       "cpu": [
         "riscv64"
       ],
@@ -1250,9 +1217,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.54.0.tgz",
-      "integrity": "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.55.1.tgz",
+      "integrity": "sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==",
       "cpu": [
         "riscv64"
       ],
@@ -1264,9 +1231,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.54.0.tgz",
-      "integrity": "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz",
+      "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==",
       "cpu": [
         "s390x"
       ],
@@ -1278,9 +1245,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.54.0.tgz",
-      "integrity": "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz",
+      "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==",
       "cpu": [
         "x64"
       ],
@@ -1292,9 +1259,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.54.0.tgz",
-      "integrity": "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz",
+      "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==",
       "cpu": [
         "x64"
       ],
@@ -1305,10 +1272,24 @@
         "linux"
       ]
     },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz",
+      "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
     "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.54.0.tgz",
-      "integrity": "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz",
+      "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==",
       "cpu": [
         "arm64"
       ],
@@ -1320,9 +1301,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.54.0.tgz",
-      "integrity": "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz",
+      "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==",
       "cpu": [
         "arm64"
       ],
@@ -1334,9 +1315,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.54.0.tgz",
-      "integrity": "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz",
+      "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==",
       "cpu": [
         "ia32"
       ],
@@ -1348,9 +1329,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.54.0.tgz",
-      "integrity": "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz",
+      "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==",
       "cpu": [
         "x64"
       ],
@@ -1362,9 +1343,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.54.0.tgz",
-      "integrity": "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz",
+      "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==",
       "cpu": [
         "x64"
       ],
@@ -1375,6 +1356,13 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@supabase/auth-js": {
       "version": "2.89.0",
       "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.89.0.tgz",
@@ -1473,6 +1461,17 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
     "node_modules/@types/connect": {
       "version": "3.4.38",
       "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
@@ -1493,6 +1492,13 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -2003,31 +2009,30 @@
       }
     },
     "node_modules/@vitest/coverage-v8": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-2.1.9.tgz",
-      "integrity": "sha512-Z2cOr0ksM00MpEfyVE8KXIYPEcBFxdbLSs56L8PO0QQMxt/6bDj45uQfxoc96v05KW3clk7vvgP0qfDit9DmfQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.0.16.tgz",
+      "integrity": "sha512-2rNdjEIsPRzsdu6/9Eq0AYAzYdpP6Bx9cje9tL3FE5XzXRQF1fNU9pe/1yE8fCrS0HD+fBtt6gLPh6LI57tX7A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@ampproject/remapping": "^2.3.0",
-        "@bcoe/v8-coverage": "^0.2.3",
-        "debug": "^4.3.7",
+        "@bcoe/v8-coverage": "^1.0.2",
+        "@vitest/utils": "4.0.16",
+        "ast-v8-to-istanbul": "^0.3.8",
         "istanbul-lib-coverage": "^3.2.2",
         "istanbul-lib-report": "^3.0.1",
         "istanbul-lib-source-maps": "^5.0.6",
-        "istanbul-reports": "^3.1.7",
-        "magic-string": "^0.30.12",
-        "magicast": "^0.3.5",
-        "std-env": "^3.8.0",
-        "test-exclude": "^7.0.1",
-        "tinyrainbow": "^1.2.0"
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.1",
+        "obug": "^2.1.1",
+        "std-env": "^3.10.0",
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
-        "@vitest/browser": "2.1.9",
-        "vitest": "2.1.9"
+        "@vitest/browser": "4.0.16",
+        "vitest": "4.0.16"
       },
       "peerDependenciesMeta": {
         "@vitest/browser": {
@@ -2035,64 +2040,41 @@
         }
       }
     },
-    "node_modules/@vitest/coverage-v8/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@vitest/coverage-v8/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@vitest/expect": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
-      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.16.tgz",
+      "integrity": "sha512-eshqULT2It7McaJkQGLkPjPjNph+uevROGuIMJdG3V+0BSR2w9u6J9Lwu+E8cK5TETlfou8GRijhafIMhXsimA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "2.1.9",
-        "@vitest/utils": "2.1.9",
-        "chai": "^5.1.2",
-        "tinyrainbow": "^1.2.0"
+        "@standard-schema/spec": "^1.0.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.0.16",
+        "@vitest/utils": "4.0.16",
+        "chai": "^6.2.1",
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/mocker": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
-      "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.16.tgz",
+      "integrity": "sha512-yb6k4AZxJTB+q9ycAvsoxGn+j/po0UaPgajllBgt1PzoMAAmJGYFdDk0uCcRcxb3BrME34I6u8gHZTQlkqSZpg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "2.1.9",
+        "@vitest/spy": "4.0.16",
         "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.12"
+        "magic-string": "^0.30.21"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "msw": "^2.4.9",
-        "vite": "^5.0.0"
+        "vite": "^6.0.0 || ^7.0.0-0"
       },
       "peerDependenciesMeta": {
         "msw": {
@@ -2104,70 +2086,66 @@
       }
     },
     "node_modules/@vitest/pretty-format": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
-      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.16.tgz",
+      "integrity": "sha512-eNCYNsSty9xJKi/UdVD8Ou16alu7AYiS2fCPRs0b1OdhJiV89buAXQLpTbe+X8V9L6qrs9CqyvU7OaAopJYPsA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tinyrainbow": "^1.2.0"
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
-      "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.16.tgz",
+      "integrity": "sha512-VWEDm5Wv9xEo80ctjORcTQRJ539EGPB3Pb9ApvVRAY1U/WkHXmmYISqU5E79uCwcW7xYUV38gwZD+RV755fu3Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "2.1.9",
-        "pathe": "^1.1.2"
+        "@vitest/utils": "4.0.16",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
-      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.16.tgz",
+      "integrity": "sha512-sf6NcrYhYBsSYefxnry+DR8n3UV4xWZwWxYbCJUt2YdvtqzSPR7VfGrY0zsv090DAbjFZsi7ZaMi1KnSRyK1XA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "2.1.9",
-        "magic-string": "^0.30.12",
-        "pathe": "^1.1.2"
+        "@vitest/pretty-format": "4.0.16",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
-      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.16.tgz",
+      "integrity": "sha512-4jIOWjKP0ZUaEmJm00E0cOBLU+5WE0BpeNr3XN6TEF05ltro6NJqHWxXD0kA8/Zc8Nh23AT8WQxwNG+WeROupw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "tinyspy": "^3.0.2"
-      },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
-      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.16.tgz",
+      "integrity": "sha512-h8z9yYhV3e1LEfaQ3zdypIrnAg/9hguReGZoS7Gl0aBG5xgA410zBqECqmaF/+RkTggRsfnzc1XaAHA6bmUufA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "2.1.9",
-        "loupe": "^3.1.2",
-        "tinyrainbow": "^1.2.0"
+        "@vitest/pretty-format": "4.0.16",
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -2297,32 +2275,6 @@
         "sql.js": "^0.5.0"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "6.2.3",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
-      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
     "node_modules/anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
@@ -2372,6 +2324,18 @@
         "node": ">=12"
       }
     },
+    "node_modules/ast-v8-to-istanbul": {
+      "version": "0.3.10",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.10.tgz",
+      "integrity": "sha512-p4K7vMz2ZSk3wN8l5o3y2bJAoZXT3VuJI5OLTATY/01CYWumWvwkUw0SqDBnNq6IiTO3qDa1eSQDibAV8g7XOQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "estree-walker": "^3.0.3",
+        "js-tokens": "^9.0.1"
+      }
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -2610,16 +2574,6 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/call-bind": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
@@ -2678,18 +2632,11 @@
       }
     },
     "node_modules/chai": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
-      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "assertion-error": "^2.0.1",
-        "check-error": "^2.1.1",
-        "deep-eql": "^5.0.1",
-        "loupe": "^3.1.0",
-        "pathval": "^2.0.0"
-      },
       "engines": {
         "node": ">=18"
       }
@@ -2755,16 +2702,6 @@
         "node": "*"
       }
     },
-    "node_modules/check-error": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
-      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      }
-    },
     "node_modules/chokidar": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
@@ -3064,16 +3001,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/deep-eql": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
-      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -3152,26 +3079,12 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
       "license": "MIT"
     },
-    "node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/encodeurl": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
@@ -3882,23 +3795,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -4058,27 +3954,6 @@
         "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
       }
     },
-    "node_modules/glob": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
-      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "foreground-child": "^3.1.0",
-        "jackspeak": "^3.1.2",
-        "minimatch": "^9.0.4",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^1.11.1"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -4092,32 +3967,6 @@
         "node": ">= 6"
       }
     },
-    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/globals": {
       "version": "14.0.0",
       "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
@@ -4466,16 +4315,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -4660,22 +4499,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/jackspeak": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
-      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      },
-      "optionalDependencies": {
-        "@pkgjs/parseargs": "^0.11.0"
-      }
-    },
     "node_modules/joycon": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
@@ -4686,6 +4509,13 @@
         "node": ">=10"
       }
     },
+    "node_modules/js-tokens": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
+      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/js-yaml": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
@@ -4799,20 +4629,6 @@
       "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
       "license": "Apache-2.0"
     },
-    "node_modules/loupe": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
-      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -4824,15 +4640,15 @@
       }
     },
     "node_modules/magicast": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.3.5.tgz",
-      "integrity": "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.1.tgz",
+      "integrity": "sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.25.4",
-        "@babel/types": "^7.25.4",
-        "source-map-js": "^1.2.0"
+        "@babel/parser": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "source-map-js": "^1.2.1"
       }
     },
     "node_modules/make-dir": {
@@ -5180,6 +4996,17 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
     "node_modules/on-exit-leak-free": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
@@ -5260,13 +5087,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
-      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0"
-    },
     "node_modules/pako": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
@@ -5315,23 +5135,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/path-scurry": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
-      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^10.2.0",
-        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/path-to-regexp": {
       "version": "0.1.12",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
@@ -5339,22 +5142,12 @@
       "license": "MIT"
     },
     "node_modules/pathe": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
-      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/pathval": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
-      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.16"
-      }
-    },
     "node_modules/pend": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
@@ -5860,9 +5653,9 @@
       }
     },
     "node_modules/rollup": {
-      "version": "4.54.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.54.0.tgz",
-      "integrity": "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw==",
+      "version": "4.55.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.55.1.tgz",
+      "integrity": "sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -5876,28 +5669,31 @@
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.54.0",
-        "@rollup/rollup-android-arm64": "4.54.0",
-        "@rollup/rollup-darwin-arm64": "4.54.0",
-        "@rollup/rollup-darwin-x64": "4.54.0",
-        "@rollup/rollup-freebsd-arm64": "4.54.0",
-        "@rollup/rollup-freebsd-x64": "4.54.0",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.54.0",
-        "@rollup/rollup-linux-arm-musleabihf": "4.54.0",
-        "@rollup/rollup-linux-arm64-gnu": "4.54.0",
-        "@rollup/rollup-linux-arm64-musl": "4.54.0",
-        "@rollup/rollup-linux-loong64-gnu": "4.54.0",
-        "@rollup/rollup-linux-ppc64-gnu": "4.54.0",
-        "@rollup/rollup-linux-riscv64-gnu": "4.54.0",
-        "@rollup/rollup-linux-riscv64-musl": "4.54.0",
-        "@rollup/rollup-linux-s390x-gnu": "4.54.0",
-        "@rollup/rollup-linux-x64-gnu": "4.54.0",
-        "@rollup/rollup-linux-x64-musl": "4.54.0",
-        "@rollup/rollup-openharmony-arm64": "4.54.0",
-        "@rollup/rollup-win32-arm64-msvc": "4.54.0",
-        "@rollup/rollup-win32-ia32-msvc": "4.54.0",
-        "@rollup/rollup-win32-x64-gnu": "4.54.0",
-        "@rollup/rollup-win32-x64-msvc": "4.54.0",
+        "@rollup/rollup-android-arm-eabi": "4.55.1",
+        "@rollup/rollup-android-arm64": "4.55.1",
+        "@rollup/rollup-darwin-arm64": "4.55.1",
+        "@rollup/rollup-darwin-x64": "4.55.1",
+        "@rollup/rollup-freebsd-arm64": "4.55.1",
+        "@rollup/rollup-freebsd-x64": "4.55.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.55.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.55.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.55.1",
+        "@rollup/rollup-linux-arm64-musl": "4.55.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.55.1",
+        "@rollup/rollup-linux-loong64-musl": "4.55.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.55.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.55.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.55.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.55.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.55.1",
+        "@rollup/rollup-linux-x64-gnu": "4.55.1",
+        "@rollup/rollup-linux-x64-musl": "4.55.1",
+        "@rollup/rollup-openbsd-x64": "4.55.1",
+        "@rollup/rollup-openharmony-arm64": "4.55.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.55.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.55.1",
+        "@rollup/rollup-win32-x64-gnu": "4.55.1",
+        "@rollup/rollup-win32-x64-msvc": "4.55.1",
         "fsevents": "~2.3.2"
       }
     },
@@ -6299,110 +6095,6 @@
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "license": "MIT"
     },
-    "node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/string-width-cjs/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
-      "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/strip-dirs": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz",
@@ -6528,47 +6220,6 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/test-exclude": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz",
-      "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@istanbuljs/schema": "^0.1.2",
-        "glob": "^10.4.1",
-        "minimatch": "^9.0.4"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/test-exclude/node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/test-exclude/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/thread-stream": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
@@ -6592,36 +6243,68 @@
       "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/tinypool": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
-      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
       }
     },
-    "node_modules/tinyrainbow": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
-      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
-        "node": ">=14.0.0"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/tinyspy": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
-      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+    "node_modules/tinyrainbow": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
+      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -6711,6 +6394,7 @@
       "integrity": "sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "~0.25.0",
         "get-tsconfig": "^4.7.5"
@@ -6884,22 +6568,24 @@
       }
     },
     "node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
@@ -6908,19 +6594,25 @@
         "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
         "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
         "@types/node": {
           "optional": true
         },
+        "jiti": {
+          "optional": true
+        },
         "less": {
           "optional": true
         },
@@ -6941,61 +6633,19 @@
         },
         "terser": {
           "optional": true
-        }
-      }
-    },
-    "node_modules/vite-node": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
-      "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.3.7",
-        "es-module-lexer": "^1.5.4",
-        "pathe": "^1.1.2",
-        "vite": "^5.0.0"
-      },
-      "bin": {
-        "vite-node": "vite-node.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/vite-node/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
           "optional": true
         }
       }
     },
-    "node_modules/vite-node/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/vite/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
+      "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==",
       "cpu": [
         "ppc64"
       ],
@@ -7006,13 +6656,13 @@
         "aix"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz",
+      "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==",
       "cpu": [
         "arm"
       ],
@@ -7023,13 +6673,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz",
+      "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==",
       "cpu": [
         "arm64"
       ],
@@ -7040,13 +6690,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz",
+      "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==",
       "cpu": [
         "x64"
       ],
@@ -7057,13 +6707,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
+      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
       "cpu": [
         "arm64"
       ],
@@ -7074,13 +6724,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz",
+      "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==",
       "cpu": [
         "x64"
       ],
@@ -7091,13 +6741,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==",
       "cpu": [
         "arm64"
       ],
@@ -7108,13 +6758,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz",
+      "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==",
       "cpu": [
         "x64"
       ],
@@ -7125,13 +6775,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz",
+      "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==",
       "cpu": [
         "arm"
       ],
@@ -7142,13 +6792,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz",
+      "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==",
       "cpu": [
         "arm64"
       ],
@@ -7159,13 +6809,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz",
+      "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==",
       "cpu": [
         "ia32"
       ],
@@ -7176,13 +6826,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz",
+      "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==",
       "cpu": [
         "loong64"
       ],
@@ -7193,13 +6843,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz",
+      "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==",
       "cpu": [
         "mips64el"
       ],
@@ -7210,13 +6860,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz",
+      "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==",
       "cpu": [
         "ppc64"
       ],
@@ -7227,13 +6877,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz",
+      "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==",
       "cpu": [
         "riscv64"
       ],
@@ -7244,13 +6894,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz",
+      "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==",
       "cpu": [
         "s390x"
       ],
@@ -7261,13 +6911,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz",
+      "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==",
       "cpu": [
         "x64"
       ],
@@ -7278,13 +6928,30 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==",
       "cpu": [
         "x64"
       ],
@@ -7295,13 +6962,30 @@
         "netbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==",
       "cpu": [
         "x64"
       ],
@@ -7312,13 +6996,30 @@
         "openbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/vite/node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz",
+      "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz",
+      "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==",
       "cpu": [
         "x64"
       ],
@@ -7329,13 +7030,13 @@
         "sunos"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz",
+      "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==",
       "cpu": [
         "arm64"
       ],
@@ -7346,13 +7047,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz",
+      "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==",
       "cpu": [
         "ia32"
       ],
@@ -7363,13 +7064,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz",
+      "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==",
       "cpu": [
         "x64"
       ],
@@ -7380,13 +7081,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/vite/node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
+      "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -7394,77 +7095,115 @@
         "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+        "@esbuild/aix-ppc64": "0.27.2",
+        "@esbuild/android-arm": "0.27.2",
+        "@esbuild/android-arm64": "0.27.2",
+        "@esbuild/android-x64": "0.27.2",
+        "@esbuild/darwin-arm64": "0.27.2",
+        "@esbuild/darwin-x64": "0.27.2",
+        "@esbuild/freebsd-arm64": "0.27.2",
+        "@esbuild/freebsd-x64": "0.27.2",
+        "@esbuild/linux-arm": "0.27.2",
+        "@esbuild/linux-arm64": "0.27.2",
+        "@esbuild/linux-ia32": "0.27.2",
+        "@esbuild/linux-loong64": "0.27.2",
+        "@esbuild/linux-mips64el": "0.27.2",
+        "@esbuild/linux-ppc64": "0.27.2",
+        "@esbuild/linux-riscv64": "0.27.2",
+        "@esbuild/linux-s390x": "0.27.2",
+        "@esbuild/linux-x64": "0.27.2",
+        "@esbuild/netbsd-arm64": "0.27.2",
+        "@esbuild/netbsd-x64": "0.27.2",
+        "@esbuild/openbsd-arm64": "0.27.2",
+        "@esbuild/openbsd-x64": "0.27.2",
+        "@esbuild/openharmony-arm64": "0.27.2",
+        "@esbuild/sunos-x64": "0.27.2",
+        "@esbuild/win32-arm64": "0.27.2",
+        "@esbuild/win32-ia32": "0.27.2",
+        "@esbuild/win32-x64": "0.27.2"
+      }
+    },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
     "node_modules/vitest": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
-      "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.16.tgz",
+      "integrity": "sha512-E4t7DJ9pESL6E3I8nFjPa4xGUd3PmiWDLsDztS2qXSJWfHtbQnwAWylaBvSNY48I3vr8PTqIZlyK8TE3V3CA4Q==",
       "dev": true,
       "license": "MIT",
       "peer": true,
       "dependencies": {
-        "@vitest/expect": "2.1.9",
-        "@vitest/mocker": "2.1.9",
-        "@vitest/pretty-format": "^2.1.9",
-        "@vitest/runner": "2.1.9",
-        "@vitest/snapshot": "2.1.9",
-        "@vitest/spy": "2.1.9",
-        "@vitest/utils": "2.1.9",
-        "chai": "^5.1.2",
-        "debug": "^4.3.7",
-        "expect-type": "^1.1.0",
-        "magic-string": "^0.30.12",
-        "pathe": "^1.1.2",
-        "std-env": "^3.8.0",
+        "@vitest/expect": "4.0.16",
+        "@vitest/mocker": "4.0.16",
+        "@vitest/pretty-format": "4.0.16",
+        "@vitest/runner": "4.0.16",
+        "@vitest/snapshot": "4.0.16",
+        "@vitest/spy": "4.0.16",
+        "@vitest/utils": "4.0.16",
+        "es-module-lexer": "^1.7.0",
+        "expect-type": "^1.2.2",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^3.10.0",
         "tinybench": "^2.9.0",
-        "tinyexec": "^0.3.1",
-        "tinypool": "^1.0.1",
-        "tinyrainbow": "^1.2.0",
-        "vite": "^5.0.0",
-        "vite-node": "2.1.9",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3",
+        "vite": "^6.0.0 || ^7.0.0",
         "why-is-node-running": "^2.3.0"
       },
       "bin": {
         "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "@edge-runtime/vm": "*",
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "2.1.9",
-        "@vitest/ui": "2.1.9",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.0.16",
+        "@vitest/browser-preview": "4.0.16",
+        "@vitest/browser-webdriverio": "4.0.16",
+        "@vitest/ui": "4.0.16",
         "happy-dom": "*",
         "jsdom": "*"
       },
@@ -7472,10 +7211,19 @@
         "@edge-runtime/vm": {
           "optional": true
         },
+        "@opentelemetry/api": {
+          "optional": true
+        },
         "@types/node": {
           "optional": true
         },
-        "@vitest/browser": {
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
           "optional": true
         },
         "@vitest/ui": {
@@ -7489,31 +7237,19 @@
         }
       }
     },
-    "node_modules/vitest/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
       "engines": {
-        "node": ">=6.0"
+        "node": ">=12"
       },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/vitest/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/web-streams-polyfill": {
       "version": "4.0.0-beta.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
@@ -7603,104 +7339,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
diff --git a/backend/package.json b/backend/package.json
index dc5d505..302c0a0 100644
--- a/backend/package.json
+++ b/backend/package.json
@@ -32,13 +32,13 @@
     "npm": ">=9.0.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^2.1.0",
     "@eslint/js": "^9.0.0",
     "@tsconfig/node-lts": "^22.0.2",
     "@types/cors": "^2.8.19",
     "@types/express": "^4.17.21",
     "@types/node": "^20.0.0",
     "@types/ws": "^8.5.12",
+    "@vitest/coverage-v8": "^4.0.16",
     "eslint": "^9.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
@@ -49,7 +49,7 @@
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.0.0",
-    "vitest": "^2.1.0"
+    "vitest": "^4.0.16"
   },
   "dependencies": {
     "@inworld/runtime": "https://storage.googleapis.com/assets-inworld-ai/node-packages/inworld-runtime-0.9.0-rc.14.tgz",
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index e697c60..5d0a7b8 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -19,14 +19,17 @@
         "@types/react-dom": "^19.2.3",
         "@vitejs/plugin-react": "^5.1.1",
         "eslint": "^9.39.1",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.1.3",
         "eslint-plugin-react-hooks": "^7.0.1",
         "eslint-plugin-react-refresh": "^0.4.24",
         "globals": "^16.5.0",
         "jsdom": "^25.0.0",
+        "prettier": "^3.2.5",
         "typescript": "~5.9.3",
         "typescript-eslint": "^8.46.4",
         "vite": "^7.2.4",
-        "vitest": "^2.1.0"
+        "vitest": "^4.0.16"
       }
     },
     "node_modules/@asamuzakjp/css-color": {
@@ -1151,6 +1154,19 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@pkgr/core": {
+      "version": "0.2.9",
+      "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz",
+      "integrity": "sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/pkgr"
+      }
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-beta.53",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.53.tgz",
@@ -1466,6 +1482,13 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@supabase/auth-js": {
       "version": "2.89.0",
       "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.89.0.tgz",
@@ -1591,6 +1614,24 @@
         "@babel/types": "^7.28.2"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -1942,86 +1983,111 @@
       }
     },
     "node_modules/@vitest/expect": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
-      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.16.tgz",
+      "integrity": "sha512-eshqULT2It7McaJkQGLkPjPjNph+uevROGuIMJdG3V+0BSR2w9u6J9Lwu+E8cK5TETlfou8GRijhafIMhXsimA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.0.16",
+        "@vitest/utils": "4.0.16",
+        "chai": "^6.2.1",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.16.tgz",
+      "integrity": "sha512-yb6k4AZxJTB+q9ycAvsoxGn+j/po0UaPgajllBgt1PzoMAAmJGYFdDk0uCcRcxb3BrME34I6u8gHZTQlkqSZpg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "2.1.9",
-        "@vitest/utils": "2.1.9",
-        "chai": "^5.1.2",
-        "tinyrainbow": "^1.2.0"
+        "@vitest/spy": "4.0.16",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
       }
     },
     "node_modules/@vitest/pretty-format": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
-      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.16.tgz",
+      "integrity": "sha512-eNCYNsSty9xJKi/UdVD8Ou16alu7AYiS2fCPRs0b1OdhJiV89buAXQLpTbe+X8V9L6qrs9CqyvU7OaAopJYPsA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tinyrainbow": "^1.2.0"
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
-      "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.16.tgz",
+      "integrity": "sha512-VWEDm5Wv9xEo80ctjORcTQRJ539EGPB3Pb9ApvVRAY1U/WkHXmmYISqU5E79uCwcW7xYUV38gwZD+RV755fu3Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "2.1.9",
-        "pathe": "^1.1.2"
+        "@vitest/utils": "4.0.16",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
-      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.16.tgz",
+      "integrity": "sha512-sf6NcrYhYBsSYefxnry+DR8n3UV4xWZwWxYbCJUt2YdvtqzSPR7VfGrY0zsv090DAbjFZsi7ZaMi1KnSRyK1XA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "2.1.9",
-        "magic-string": "^0.30.12",
-        "pathe": "^1.1.2"
+        "@vitest/pretty-format": "4.0.16",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
-      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.16.tgz",
+      "integrity": "sha512-4jIOWjKP0ZUaEmJm00E0cOBLU+5WE0BpeNr3XN6TEF05ltro6NJqHWxXD0kA8/Zc8Nh23AT8WQxwNG+WeROupw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "tinyspy": "^3.0.2"
-      },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
-      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.16.tgz",
+      "integrity": "sha512-h8z9yYhV3e1LEfaQ3zdypIrnAg/9hguReGZoS7Gl0aBG5xgA410zBqECqmaF/+RkTggRsfnzc1XaAHA6bmUufA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "2.1.9",
-        "loupe": "^3.1.2",
-        "tinyrainbow": "^1.2.0"
+        "@vitest/pretty-format": "4.0.16",
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -2181,16 +2247,6 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -2237,18 +2293,11 @@
       "license": "CC-BY-4.0"
     },
     "node_modules/chai": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
-      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "assertion-error": "^2.0.1",
-        "check-error": "^2.1.1",
-        "deep-eql": "^5.0.1",
-        "loupe": "^3.1.0",
-        "pathval": "^2.0.0"
-      },
       "engines": {
         "node": ">=18"
       }
@@ -2270,16 +2319,6 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/check-error": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
-      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      }
-    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2409,16 +2448,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/deep-eql": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
-      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -2653,6 +2682,51 @@
         }
       }
     },
+    "node_modules/eslint-config-prettier": {
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.1.2.tgz",
+      "integrity": "sha512-iI1f+D2ViGn+uvv5HuHVUamg8ll4tN+JRHGc6IJi4TP9Kl976C57fzPXgseXNs8v0iA8aSJpHsTWjDb9QJamGQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "eslint-config-prettier": "bin/cli.js"
+      },
+      "peerDependencies": {
+        "eslint": ">=7.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-prettier": {
+      "version": "5.5.4",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.4.tgz",
+      "integrity": "sha512-swNtI95SToIz05YINMA6Ox5R057IMAmWZ26GqPxusAp1TZzj+IdY9tXNWWD3vkF/wEqydCONcwjTFpxybBqZsg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prettier-linter-helpers": "^1.0.0",
+        "synckit": "^0.11.7"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-plugin-prettier"
+      },
+      "peerDependencies": {
+        "@types/eslint": ">=8.0.0",
+        "eslint": ">=8.0.0",
+        "eslint-config-prettier": ">= 7.0.0 <10.0.0 || >=10.1.0",
+        "prettier": ">=3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/eslint": {
+          "optional": true
+        },
+        "eslint-config-prettier": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/eslint-plugin-react-hooks": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
@@ -2804,6 +2878,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/fast-diff": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz",
+      "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
     "node_modules/fast-json-stable-stringify": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
@@ -3379,13 +3460,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/loupe": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
-      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -3499,6 +3573,17 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -3596,22 +3681,12 @@
       }
     },
     "node_modules/pathe": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
-      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/pathval": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
-      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.16"
-      }
-    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -3672,6 +3747,36 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/prettier": {
+      "version": "3.7.4",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.7.4.tgz",
+      "integrity": "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/prettier-linter-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.1.tgz",
+      "integrity": "sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-diff": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -3896,6 +4001,22 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/synckit": {
+      "version": "0.11.11",
+      "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.11.11.tgz",
+      "integrity": "sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@pkgr/core": "^0.2.9"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/synckit"
+      }
+    },
     "node_modules/tinybench": {
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -3904,11 +4025,14 @@
       "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
@@ -3927,30 +4051,10 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/tinypool": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
-      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      }
-    },
     "node_modules/tinyrainbow": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
-      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/tinyspy": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
-      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
+      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4197,1099 +4301,80 @@
         }
       }
     },
-    "node_modules/vite-node": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
-      "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.3.7",
-        "es-module-lexer": "^1.5.4",
-        "pathe": "^1.1.2",
-        "vite": "^5.0.0"
+    "node_modules/vitest": {
+      "version": "4.0.16",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.16.tgz",
+      "integrity": "sha512-E4t7DJ9pESL6E3I8nFjPa4xGUd3PmiWDLsDztS2qXSJWfHtbQnwAWylaBvSNY48I3vr8PTqIZlyK8TE3V3CA4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.0.16",
+        "@vitest/mocker": "4.0.16",
+        "@vitest/pretty-format": "4.0.16",
+        "@vitest/runner": "4.0.16",
+        "@vitest/snapshot": "4.0.16",
+        "@vitest/spy": "4.0.16",
+        "@vitest/utils": "4.0.16",
+        "es-module-lexer": "^1.7.0",
+        "expect-type": "^1.2.2",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^3.10.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3",
+        "vite": "^6.0.0 || ^7.0.0",
+        "why-is-node-running": "^2.3.0"
       },
       "bin": {
-        "vite-node": "vite-node.mjs"
+        "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite-node/node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
-      }
-    },
-    "node_modules/vite-node/node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vitest": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
-      "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@vitest/expect": "2.1.9",
-        "@vitest/mocker": "2.1.9",
-        "@vitest/pretty-format": "^2.1.9",
-        "@vitest/runner": "2.1.9",
-        "@vitest/snapshot": "2.1.9",
-        "@vitest/spy": "2.1.9",
-        "@vitest/utils": "2.1.9",
-        "chai": "^5.1.2",
-        "debug": "^4.3.7",
-        "expect-type": "^1.1.0",
-        "magic-string": "^0.30.12",
-        "pathe": "^1.1.2",
-        "std-env": "^3.8.0",
-        "tinybench": "^2.9.0",
-        "tinyexec": "^0.3.1",
-        "tinypool": "^1.0.1",
-        "tinyrainbow": "^1.2.0",
-        "vite": "^5.0.0",
-        "vite-node": "2.1.9",
-        "why-is-node-running": "^2.3.0"
-      },
-      "bin": {
-        "vitest": "vitest.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      },
-      "peerDependencies": {
-        "@edge-runtime/vm": "*",
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "2.1.9",
-        "@vitest/ui": "2.1.9",
-        "happy-dom": "*",
-        "jsdom": "*"
-      },
-      "peerDependenciesMeta": {
-        "@edge-runtime/vm": {
-          "optional": true
-        },
-        "@types/node": {
-          "optional": true
-        },
-        "@vitest/browser": {
-          "optional": true
-        },
-        "@vitest/ui": {
-          "optional": true
-        },
-        "happy-dom": {
-          "optional": true
-        },
-        "jsdom": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitest/node_modules/@vitest/mocker": {
-      "version": "2.1.9",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
-      "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@vitest/spy": "2.1.9",
-        "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.12"
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
-        "msw": "^2.4.9",
-        "vite": "^5.0.0"
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.0.16",
+        "@vitest/browser-preview": "4.0.16",
+        "@vitest/browser-webdriverio": "4.0.16",
+        "@vitest/ui": "4.0.16",
+        "happy-dom": "*",
+        "jsdom": "*"
       },
       "peerDependenciesMeta": {
-        "msw": {
+        "@edge-runtime/vm": {
           "optional": true
         },
-        "vite": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vitest/node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
-      }
-    },
-    "node_modules/vitest/node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
+        "@opentelemetry/api": {
           "optional": true
         },
-        "less": {
+        "@types/node": {
           "optional": true
         },
-        "lightningcss": {
+        "@vitest/browser-playwright": {
           "optional": true
         },
-        "sass": {
+        "@vitest/browser-preview": {
           "optional": true
         },
-        "sass-embedded": {
+        "@vitest/browser-webdriverio": {
           "optional": true
         },
-        "stylus": {
+        "@vitest/ui": {
           "optional": true
         },
-        "sugarss": {
+        "happy-dom": {
           "optional": true
         },
-        "terser": {
+        "jsdom": {
           "optional": true
         }
       }
diff --git a/frontend/package.json b/frontend/package.json
index 1fd3274..0fe7d9c 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -22,7 +22,6 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
-    "jsdom": "^25.0.0",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -33,10 +32,11 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "jsdom": "^25.0.0",
     "prettier": "^3.2.5",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
     "vite": "^7.2.4",
-    "vitest": "^2.1.0"
+    "vitest": "^4.0.16"
   }
 }

From 1efb5bd12cd6f0a5f63defecb1619b395e9a7f29 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 11:35:37 -0800
Subject: [PATCH 36/49] Fixed linter issues

---
 backend/src/config/server.ts                  |   1 -
 .../configs/flashcard-generation-graph.json   |  10 +-
 .../lang-learning-conversation-graph.json     |  10 +-
 .../configs/response-feedback-graph.json      |  10 +-
 backend/tsconfig.eslint.json                  |   2 +-
 backend/tsconfig.json                         |   7 +-
 frontend/eslint.config.mjs                    |  17 ++-
 .../src/__tests__/services/Storage.test.ts    |  41 +++---
 frontend/src/context/AppContext.tsx           | 122 ++++++++++++------
 frontend/src/context/AuthContext.tsx          |   4 +-
 frontend/src/services/AudioHandler.ts         |   6 +-
 frontend/src/services/AudioPlayer.ts          |   6 +-
 12 files changed, 146 insertions(+), 90 deletions(-)

diff --git a/backend/src/config/server.ts b/backend/src/config/server.ts
index 8ed8338..aa6f9ac 100644
--- a/backend/src/config/server.ts
+++ b/backend/src/config/server.ts
@@ -111,4 +111,3 @@ export function getAssemblyAISettingsForEagerness(
 ): AssemblyAITurnDetectionSettings {
   return assemblyAIPresets[eagerness];
 }
-
diff --git a/backend/src/graphs/configs/flashcard-generation-graph.json b/backend/src/graphs/configs/flashcard-generation-graph.json
index 7cb5d7b..a73589e 100644
--- a/backend/src/graphs/configs/flashcard-generation-graph.json
+++ b/backend/src/graphs/configs/flashcard-generation-graph.json
@@ -70,12 +70,8 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": [
-      "flashcard-parser"
-    ],
-    "start_nodes": [
-      "flashcard-prompt-builder"
-    ]
+    "end_nodes": ["flashcard-parser"],
+    "start_nodes": ["flashcard-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/src/graphs/configs/lang-learning-conversation-graph.json b/backend/src/graphs/configs/lang-learning-conversation-graph.json
index 4c34e49..311da8f 100644
--- a/backend/src/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/src/graphs/configs/lang-learning-conversation-graph.json
@@ -233,12 +233,8 @@
         "loop": true
       }
     ],
-    "end_nodes": [
-      "tts-node-lang-learning"
-    ],
-    "start_nodes": [
-      "audio-input-proxy-lang-learning"
-    ]
+    "end_nodes": ["tts-node-lang-learning"],
+    "start_nodes": ["audio-input-proxy-lang-learning"]
   },
   "components": [
     {
@@ -290,4 +286,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/src/graphs/configs/response-feedback-graph.json b/backend/src/graphs/configs/response-feedback-graph.json
index 978b019..d694a2b 100644
--- a/backend/src/graphs/configs/response-feedback-graph.json
+++ b/backend/src/graphs/configs/response-feedback-graph.json
@@ -70,12 +70,8 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": [
-      "feedback-extractor"
-    ],
-    "start_nodes": [
-      "feedback-prompt-builder"
-    ]
+    "end_nodes": ["feedback-extractor"],
+    "start_nodes": ["feedback-prompt-builder"]
   },
   "components": [
     {
@@ -92,4 +88,4 @@
       }
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/backend/tsconfig.eslint.json b/backend/tsconfig.eslint.json
index 631f88a..6b5a2b1 100644
--- a/backend/tsconfig.eslint.json
+++ b/backend/tsconfig.eslint.json
@@ -1,5 +1,5 @@
 {
   "extends": "./tsconfig.json",
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "vitest.config.ts"],
   "exclude": ["node_modules", "dist"]
 }
diff --git a/backend/tsconfig.json b/backend/tsconfig.json
index f2ce9ec..ef82c5e 100644
--- a/backend/tsconfig.json
+++ b/backend/tsconfig.json
@@ -23,10 +23,5 @@
     "noEmit": false
   },
   "include": ["src/**/*"],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts"
-  ]
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts", "src/**/*.spec.ts"]
 }
diff --git a/frontend/eslint.config.mjs b/frontend/eslint.config.mjs
index 3a5802e..d89d64e 100644
--- a/frontend/eslint.config.mjs
+++ b/frontend/eslint.config.mjs
@@ -52,7 +52,22 @@ export default [
     },
   },
   {
-    ignores: ['dist/**', 'node_modules/**', '*.js', '*.config.js'],
+    files: ['**/context/**/*.tsx'],
+    rules: {
+      'react-refresh/only-export-components': 'off',
+    },
+  },
+  {
+    files: ['public/**/*.js'],
+    languageOptions: {
+      globals: {
+        AudioWorkletProcessor: 'readonly',
+        registerProcessor: 'readonly',
+      },
+    },
+  },
+  {
+    ignores: ['dist/**', 'node_modules/**', '*.config.js', '**/*.js', '!public'],
   },
 ];
 
diff --git a/frontend/src/__tests__/services/Storage.test.ts b/frontend/src/__tests__/services/Storage.test.ts
index 1bb9f17..c121715 100644
--- a/frontend/src/__tests__/services/Storage.test.ts
+++ b/frontend/src/__tests__/services/Storage.test.ts
@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { Storage } from '../../services/Storage';
+import type { Flashcard } from '../../types';
 
 describe('Storage', () => {
   let storage: Storage;
@@ -172,7 +173,7 @@ describe('Storage', () => {
       const cards = [
         { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
       ];
-      const result = storage.addFlashcards(cards as any, 'es');
+      const result = storage.addFlashcards(cards as Partial<Flashcard>[], 'es');
 
       expect(result.length).toBe(1);
       expect(result[0].targetWord).toBe('hola');
@@ -182,13 +183,16 @@ describe('Storage', () => {
       const cards1 = [
         { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
       ];
-      storage.addFlashcards(cards1 as any, 'es');
+      storage.addFlashcards(cards1 as Partial<Flashcard>[], 'es');
 
       const cards2 = [
         { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
         { targetWord: 'adios', english: 'goodbye', example: '', mnemonic: '' },
       ];
-      const result = storage.addFlashcards(cards2 as any, 'es');
+      const result = storage.addFlashcards(
+        cards2 as Partial<Flashcard>[],
+        'es'
+      );
 
       // Should only have 2 cards (hola + adios), not 3
       expect(result.length).toBe(2);
@@ -198,7 +202,7 @@ describe('Storage', () => {
       const cards1 = [
         { targetWord: 'Hola', english: 'hello', example: '', mnemonic: '' },
       ];
-      storage.addFlashcards(cards1 as any, 'es');
+      storage.addFlashcards(cards1 as Partial<Flashcard>[], 'es');
 
       const cards2 = [
         {
@@ -208,7 +212,10 @@ describe('Storage', () => {
           mnemonic: '',
         },
       ];
-      const result = storage.addFlashcards(cards2 as any, 'es');
+      const result = storage.addFlashcards(
+        cards2 as Partial<Flashcard>[],
+        'es'
+      );
 
       expect(result.length).toBe(1);
       expect(result[0].targetWord).toBe('Hola');
@@ -218,7 +225,7 @@ describe('Storage', () => {
       const cards = [
         { targetWord: 'bonjour', english: 'hello', example: '', mnemonic: '' },
       ];
-      const result = storage.addFlashcards(cards as any, 'fr');
+      const result = storage.addFlashcards(cards as Partial<Flashcard>[], 'fr');
 
       expect(result[0].languageCode).toBe('fr');
     });
@@ -227,7 +234,7 @@ describe('Storage', () => {
       const cards = [
         { spanish: 'hola', english: 'hello', example: '', mnemonic: '' },
       ];
-      const result = storage.addFlashcards(cards as any, 'es');
+      const result = storage.addFlashcards(cards as Partial<Flashcard>[], 'es');
 
       expect(result[0].targetWord).toBe('hola');
     });
@@ -243,7 +250,7 @@ describe('Storage', () => {
               example: '',
               mnemonic: '',
             },
-          ] as any,
+          ] as Partial<Flashcard>[],
           'es'
         );
       }
@@ -258,7 +265,7 @@ describe('Storage', () => {
       storage.addFlashcards(
         [
           { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
-        ] as any,
+        ] as Partial<Flashcard>[],
         'es'
       );
       storage.clearFlashcards('es');
@@ -271,7 +278,7 @@ describe('Storage', () => {
       storage.addFlashcards(
         [
           { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
-        ] as any,
+        ] as Partial<Flashcard>[],
         'es'
       );
       storage.addFlashcards(
@@ -282,7 +289,7 @@ describe('Storage', () => {
             example: '',
             mnemonic: '',
           },
-        ] as any,
+        ] as Partial<Flashcard>[],
         'fr'
       );
 
@@ -300,7 +307,11 @@ describe('Storage', () => {
         { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
       ];
 
-      storage.addFlashcardsForConversation(conv.id, cards as any, 'es');
+      storage.addFlashcardsForConversation(
+        conv.id,
+        cards as Partial<Flashcard>[],
+        'es'
+      );
       const result = storage.getFlashcardsForConversation(conv.id);
 
       expect(result.length).toBe(1);
@@ -315,7 +326,7 @@ describe('Storage', () => {
         conv1.id,
         [
           { targetWord: 'hola', english: 'hello', example: '', mnemonic: '' },
-        ] as any,
+        ] as Partial<Flashcard>[],
         'es'
       );
       storage.addFlashcardsForConversation(
@@ -327,7 +338,7 @@ describe('Storage', () => {
             example: '',
             mnemonic: '',
           },
-        ] as any,
+        ] as Partial<Flashcard>[],
         'es'
       );
 
@@ -356,7 +367,7 @@ describe('Storage', () => {
       const conv1 = storage.createConversation('es');
 
       // Wait a tiny bit to ensure different timestamps
-      const conv2 = storage.createConversation('fr');
+      storage.createConversation('fr');
 
       // Update conv1 to make it more recent
       storage.saveConversation(conv1.id, [], 'es');
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 0de3db0..8329c85 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -5,6 +5,7 @@ import React, {
   useEffect,
   useRef,
   useCallback,
+  useMemo,
   type ReactNode,
 } from 'react';
 import type {
@@ -238,22 +239,35 @@ interface AppProviderProps {
 
 export function AppProvider({ children }: AppProviderProps) {
   const { supabase, user } = useAuth();
-  const storageRef = useRef(new HybridStorage());
-  const wsClientRef = useRef(new WebSocketClient(getWebSocketUrl()));
-  const audioHandlerRef = useRef(new AudioHandler());
-  const audioPlayerRef = useRef(new AudioPlayer());
-  const ttsAudioPlayerRef = useRef(new AudioPlayer());
+  // Create instances directly using useMemo - these are stable and don't change
+  const storageInstance = useMemo(() => new HybridStorage(), []);
+  const storageRef = useRef(storageInstance);
+  const wsClientInstance = useMemo(
+    () => new WebSocketClient(getWebSocketUrl()),
+    []
+  );
+  const wsClientRef = useRef(wsClientInstance);
+  const audioHandlerInstance = useMemo(() => new AudioHandler(), []);
+  const audioHandlerRef = useRef(audioHandlerInstance);
+  const audioPlayerInstance = useMemo(() => new AudioPlayer(), []);
+  const audioPlayerRef = useRef(audioPlayerInstance);
+  const ttsAudioPlayerInstance = useMemo(() => new AudioPlayer(), []);
+  const ttsAudioPlayerRef = useRef(ttsAudioPlayerInstance);
   const hasMigratedRef = useRef(false);
 
   const [state, dispatch] = useReducer(
     appReducer,
-    storageRef.current,
+    storageInstance,
     createInitialState
   );
 
   // Refs for tracking state in callbacks
   const stateRef = useRef(state);
-  stateRef.current = state;
+
+  // Update stateRef in effect to avoid updating ref during render
+  useEffect(() => {
+    stateRef.current = state;
+  }, [state]);
 
   // Connect/disconnect Supabase based on auth state
   useEffect(() => {
@@ -347,29 +361,32 @@ export function AppProvider({ children }: AppProviderProps) {
 
   // Initialize audio players
   useEffect(() => {
-    audioPlayerRef.current.initialize().catch(console.error);
-    ttsAudioPlayerRef.current.initialize().catch(console.error);
+    const audioPlayer = audioPlayerRef.current;
+    const ttsAudioPlayer = ttsAudioPlayerRef.current;
+    audioPlayer.initialize().catch(console.error);
+    ttsAudioPlayer.initialize().catch(console.error);
     return () => {
-      audioPlayerRef.current.destroy();
-      ttsAudioPlayerRef.current.destroy();
+      audioPlayer.destroy();
+      ttsAudioPlayer.destroy();
     };
   }, []);
 
   // Load initial state (conversations across all languages)
   useEffect(() => {
     const storage = storageRef.current;
+    const currentLang = stateRef.current.currentLanguage;
 
     // Load ALL conversations across all languages
     const allConversations = storage.getAllConversations();
     dispatch({ type: 'SET_CONVERSATIONS', payload: allConversations });
 
     // Load current conversation or use the most recent one
-    let currentId = storage.getCurrentConversationId(state.currentLanguage);
+    let currentId = storage.getCurrentConversationId(currentLang);
     if (!currentId && allConversations.length > 0) {
       currentId = allConversations[0].id;
       // Update language to match the most recent conversation
       const mostRecentConvo = allConversations[0];
-      if (mostRecentConvo.languageCode !== state.currentLanguage) {
+      if (mostRecentConvo.languageCode !== currentLang) {
         dispatch({
           type: 'SET_LANGUAGE',
           payload: mostRecentConvo.languageCode,
@@ -428,8 +445,9 @@ export function AppProvider({ children }: AppProviderProps) {
             payload: data.languages,
           });
 
+          const currentLang = stateRef.current.currentLanguage;
           const isValidLanguage = data.languages.some(
-            (lang: Language) => lang.code === state.currentLanguage
+            (lang: Language) => lang.code === currentLang
           );
           if (!isValidLanguage) {
             dispatch({
@@ -651,8 +669,10 @@ export function AppProvider({ children }: AppProviderProps) {
     }
   }, []);
 
-  // Keep refs updated
-  checkAndUpdateConversationRef.current = checkAndUpdateConversation;
+  // Update refs in effect to avoid updating during render
+  useEffect(() => {
+    checkAndUpdateConversationRef.current = checkAndUpdateConversation;
+  }, [checkAndUpdateConversation]);
 
   // Process any pending flashcards that were queued before conversation existed
   const processPendingFlashcards = useCallback((conversationId: string) => {
@@ -673,8 +693,10 @@ export function AppProvider({ children }: AppProviderProps) {
     }
   }, []);
 
-  // Keep ref updated
-  processPendingFlashcardsRef.current = processPendingFlashcards;
+  // Update refs in effect to avoid updating during render
+  useEffect(() => {
+    processPendingFlashcardsRef.current = processPendingFlashcards;
+  }, [processPendingFlashcards]);
 
   // Process pending flashcards when conversation ID becomes available
   // This handles the race condition where flashcards arrive before the conversation is created
@@ -717,8 +739,10 @@ export function AppProvider({ children }: AppProviderProps) {
     }
   }, []);
 
-  // Keep refs updated
-  handleInterruptRef.current = handleInterrupt;
+  // Update refs in effect to avoid updating during render
+  useEffect(() => {
+    handleInterruptRef.current = handleInterrupt;
+  }, [handleInterrupt]);
 
   // Setup WebSocket event listeners - runs once on mount
   useEffect(() => {
@@ -1379,24 +1403,46 @@ export function AppProvider({ children }: AppProviderProps) {
     });
   }, []);
 
-  const value: AppContextType = {
-    state,
-    dispatch,
-    storage: storageRef.current,
-    wsClient: wsClientRef.current,
-    audioHandler: audioHandlerRef.current,
-    audioPlayer: audioPlayerRef.current,
-    toggleRecording,
-    changeLanguage,
-    handleInterrupt,
-    sendTextMessage,
-    pronounceWord,
-    selectConversation,
-    createNewConversation,
-    deleteConversation,
-    renameConversation,
-    toggleSidebar,
-  };
+  // Use direct instances instead of refs for context value
+  // These instances are stable and don't change, so accessing them during render is safe
+  const value: AppContextType = useMemo(
+    () => ({
+      state,
+      dispatch,
+      storage: storageInstance,
+      wsClient: wsClientInstance,
+      audioHandler: audioHandlerInstance,
+      audioPlayer: audioPlayerInstance,
+      toggleRecording,
+      changeLanguage,
+      handleInterrupt,
+      sendTextMessage,
+      pronounceWord,
+      selectConversation,
+      createNewConversation,
+      deleteConversation,
+      renameConversation,
+      toggleSidebar,
+    }),
+    [
+      state,
+      dispatch,
+      storageInstance,
+      wsClientInstance,
+      audioHandlerInstance,
+      audioPlayerInstance,
+      toggleRecording,
+      changeLanguage,
+      handleInterrupt,
+      sendTextMessage,
+      pronounceWord,
+      selectConversation,
+      createNewConversation,
+      deleteConversation,
+      renameConversation,
+      toggleSidebar,
+    ]
+  );
 
   return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
 }
diff --git a/frontend/src/context/AuthContext.tsx b/frontend/src/context/AuthContext.tsx
index 44a4756..1d61dfe 100644
--- a/frontend/src/context/AuthContext.tsx
+++ b/frontend/src/context/AuthContext.tsx
@@ -42,13 +42,11 @@ export function AuthProvider({ children }: { children: ReactNode }) {
 
   const [user, setUser] = useState<User | null>(null);
   const [session, setSession] = useState<Session | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-
   const isConfigured = supabase !== null;
+  const [isLoading, setIsLoading] = useState(isConfigured);
 
   useEffect(() => {
     if (!supabase) {
-      setIsLoading(false);
       return;
     }
 
diff --git a/frontend/src/services/AudioHandler.ts b/frontend/src/services/AudioHandler.ts
index b268fea..1c0a51f 100644
--- a/frontend/src/services/AudioHandler.ts
+++ b/frontend/src/services/AudioHandler.ts
@@ -106,9 +106,11 @@ export class AudioHandler {
       this.stream = await navigator.mediaDevices.getUserMedia(constraints);
       console.log('Microphone access granted for continuous streaming');
 
-      this.audioContext = new (window.AudioContext ||
+      this.audioContext = new (
+        window.AudioContext ||
         (window as unknown as { webkitAudioContext: typeof AudioContext })
-          .webkitAudioContext)();
+          .webkitAudioContext
+      )();
 
       if (this.audioContext.state === 'suspended') {
         console.log('Audio context suspended, resuming...');
diff --git a/frontend/src/services/AudioPlayer.ts b/frontend/src/services/AudioPlayer.ts
index 950fc82..eef0f6f 100644
--- a/frontend/src/services/AudioPlayer.ts
+++ b/frontend/src/services/AudioPlayer.ts
@@ -40,9 +40,11 @@ export class AudioPlayer {
 
   async initialize(): Promise<void> {
     try {
-      this.audioContext = new (window.AudioContext ||
+      this.audioContext = new (
+        window.AudioContext ||
         (window as unknown as { webkitAudioContext: typeof AudioContext })
-          .webkitAudioContext)();
+          .webkitAudioContext
+      )();
 
       if (this.audioContext.state === 'suspended') {
         await this.audioContext.resume();

From 4c07788c7f2e83dcf0e619870f5f449d5c1d2d24 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 11:37:53 -0800
Subject: [PATCH 37/49] Updated lint workflow file

---
 .github/workflows/lint.yml | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 776e516..b7d3f92 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -21,14 +21,28 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: '20'
-          cache: 'npm'
 
-      - name: Install dependencies
+      - name: Install backend dependencies
+        working-directory: ./backend
         run: npm ci
 
-      - name: Run ESLint
+      - name: Install frontend dependencies
+        working-directory: ./frontend
+        run: npm ci
+
+      - name: Run ESLint (backend)
+        working-directory: ./backend
+        run: npm run lint
+
+      - name: Run ESLint (frontend)
+        working-directory: ./frontend
         run: npm run lint
 
-      - name: Check Prettier formatting
+      - name: Check Prettier formatting (backend)
+        working-directory: ./backend
+        run: npm run format:check
+
+      - name: Check Prettier formatting (frontend)
+        working-directory: ./frontend
         run: npm run format:check
 

From f918d4b753ee39c57010311b21c696de337a8586 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 15:06:41 -0800
Subject: [PATCH 38/49] Fixed bug with message duplicates

---
 frontend/src/context/AppContext.tsx | 207 ++++++++--------------------
 1 file changed, 59 insertions(+), 148 deletions(-)

diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 8329c85..6a11858 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -344,11 +344,9 @@ export function AppProvider({ children }: AppProviderProps) {
   }, [supabase, user]);
 
   const pendingLLMResponseRef = useRef<string | null>(null);
-  const lastPendingTranscriptionRef = useRef<string | null>(null);
-  // Track the last processed pair to prevent duplicate additions
-  const lastProcessedPairRef = useRef<{ user: string; teacher: string } | null>(
-    null
-  );
+  // Track if the last message was sent via text input (vs audio)
+  // This allows us to ignore transcription events for text messages
+  const lastMessageWasTextRef = useRef<boolean>(false);
   // Queue flashcards when conversation doesn't exist yet (race condition fix)
   const pendingFlashcardsRef = useRef<Flashcard[]>([]);
 
@@ -508,22 +506,8 @@ export function AppProvider({ children }: AppProviderProps) {
       conversationTitle = currentConvo?.title || null;
     }
 
-    const lastUserMessage = currentState.chatHistory
-      .filter((m) => m.role === 'learner')
-      .pop();
-    const lastTeacherMessage = currentState.chatHistory
-      .filter((m) => m.role === 'teacher')
-      .pop();
-
     // Case 1: We have a pending LLM response but user message was already added (text input case)
     if (pendingLLMResponse && !pendingTranscription) {
-      // Check if teacher response is already in history
-      if (lastTeacherMessage?.content === pendingLLMResponse) {
-        pendingLLMResponseRef.current = null;
-        dispatch({ type: 'RESET_STREAMING_STATE' });
-        return;
-      }
-
       // Add only the teacher response
       storage.addMessage('assistant', pendingLLMResponse);
       dispatch({
@@ -541,124 +525,38 @@ export function AppProvider({ children }: AppProviderProps) {
 
     // Case 2: We have both pending transcription and LLM response (audio input case)
     if (pendingTranscription && pendingLLMResponse) {
-      // Check if we've already processed this exact pair (using ref for synchronous check)
-      const lastPair = lastProcessedPairRef.current;
+      // Auto-rename conversation on first user message (if still has default name)
       if (
-        lastPair &&
-        lastPair.user === pendingTranscription &&
-        lastPair.teacher === pendingLLMResponse
+        conversationId &&
+        conversationTitle &&
+        /^Chat \d{5}$/.test(conversationTitle)
       ) {
-        // Already processed this pair, just clean up
-        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
-        pendingLLMResponseRef.current = null;
-        dispatch({ type: 'RESET_STREAMING_STATE' });
-        return;
-      }
-
-      const isDuplicate =
-        lastUserMessage?.content === pendingTranscription &&
-        lastTeacherMessage?.content === pendingLLMResponse;
-
-      if (isDuplicate) {
-        lastProcessedPairRef.current = {
-          user: pendingTranscription,
-          teacher: pendingLLMResponse,
-        };
-        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
-        pendingLLMResponseRef.current = null;
-        dispatch({ type: 'RESET_STREAMING_STATE' });
-        return;
-      }
-
-      const teacherAlreadyAdded =
-        lastTeacherMessage?.content === pendingLLMResponse;
-      const userAlreadyAdded =
-        lastUserMessage?.content === pendingTranscription;
-
-      // Mark this pair as processed BEFORE adding (synchronous protection)
-      lastProcessedPairRef.current = {
-        user: pendingTranscription,
-        teacher: pendingLLMResponse,
-      };
-
-      if (teacherAlreadyAdded && !userAlreadyAdded) {
-        // Auto-rename conversation on first user message (if still has default name)
-        if (
-          conversationId &&
-          conversationTitle &&
-          /^Chat \d{5}$/.test(conversationTitle)
-        ) {
-          const newTitle =
-            pendingTranscription.length > 10
-              ? pendingTranscription.slice(0, 10) + '...'
-              : pendingTranscription;
-          storage.renameConversation(
-            conversationId,
-            newTitle,
-            currentState.currentLanguage
-          );
-          dispatch({
-            type: 'RENAME_CONVERSATION',
-            payload: { id: conversationId, title: newTitle },
-          });
-        }
-
-        storage.addMessage('user', pendingTranscription);
+        const newTitle =
+          pendingTranscription.length > 10
+            ? pendingTranscription.slice(0, 10) + '...'
+            : pendingTranscription;
+        storage.renameConversation(
+          conversationId,
+          newTitle,
+          currentState.currentLanguage
+        );
         dispatch({
-          type: 'ADD_MESSAGE',
-          payload: { role: 'learner', content: pendingTranscription },
-        });
-
-        const conversationHistory = storage.getConversationHistory();
-        wsClient.send({
-          type: 'conversation_update',
-          data: conversationHistory,
+          type: 'RENAME_CONVERSATION',
+          payload: { id: conversationId, title: newTitle },
         });
-
-        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
-        pendingLLMResponseRef.current = null;
-        dispatch({ type: 'RESET_STREAMING_STATE' });
-        return;
       }
 
-      // Add user message only if not already added
-      if (!userAlreadyAdded) {
-        // Auto-rename conversation on first user message (if still has default name)
-        if (
-          conversationId &&
-          conversationTitle &&
-          /^Chat \d{5}$/.test(conversationTitle)
-        ) {
-          const newTitle =
-            pendingTranscription.length > 10
-              ? pendingTranscription.slice(0, 10) + '...'
-              : pendingTranscription;
-          storage.renameConversation(
-            conversationId,
-            newTitle,
-            currentState.currentLanguage
-          );
-          dispatch({
-            type: 'RENAME_CONVERSATION',
-            payload: { id: conversationId, title: newTitle },
-          });
-        }
-
-        storage.addMessage('user', pendingTranscription);
-        dispatch({
-          type: 'ADD_MESSAGE',
-          payload: { role: 'learner', content: pendingTranscription },
-        });
-      }
+      storage.addMessage('user', pendingTranscription);
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'learner', content: pendingTranscription },
+      });
 
-      // Add teacher message only if not already added
-      if (!teacherAlreadyAdded) {
-        storage.addMessage('assistant', pendingLLMResponse);
-        dispatch({
-          type: 'ADD_MESSAGE',
-          payload: { role: 'teacher', content: pendingLLMResponse },
-        });
-      }
+      storage.addMessage('assistant', pendingLLMResponse);
+      dispatch({
+        type: 'ADD_MESSAGE',
+        payload: { role: 'teacher', content: pendingLLMResponse },
+      });
 
       const conversationHistory = storage.getConversationHistory();
       wsClient.send({ type: 'conversation_update', data: conversationHistory });
@@ -811,15 +709,35 @@ export function AppProvider({ children }: AppProviderProps) {
       dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
       dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
 
-      // Check if this transcription was already added (e.g., by sendTextMessage)
-      const alreadyAdded = lastPendingTranscriptionRef.current === text;
+      // If the last message was sent via text input, ignore this transcription event
+      // because the user message was already added in sendTextMessage
+      if (lastMessageWasTextRef.current) {
+        lastMessageWasTextRef.current = false;
+        // Still need to check for LLM response and update conversation
+        if (
+          pendingLLMResponseRef.current &&
+          !stateRef.current.streamingLLMResponse
+        ) {
+          checkAndUpdateConversationRef.current();
+        }
+
+        if (
+          stateRef.current.streamingLLMResponse?.trim() &&
+          stateRef.current.llmResponseComplete &&
+          !pendingLLMResponseRef.current
+        ) {
+          pendingLLMResponseRef.current = stateRef.current.streamingLLMResponse;
+          checkAndUpdateConversationRef.current();
+        }
 
-      if (!alreadyAdded) {
-        // Only set pending transcription for audio-based transcriptions
-        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
-        lastPendingTranscriptionRef.current = text;
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        checkAndUpdateConversationRef.current();
+        return;
       }
 
+      // This is an audio-based transcription - set pending transcription
+      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
+
       if (
         pendingLLMResponseRef.current &&
         !stateRef.current.streamingLLMResponse
@@ -837,10 +755,7 @@ export function AppProvider({ children }: AppProviderProps) {
       }
 
       dispatch({ type: 'RESET_STREAMING_STATE' });
-
-      if (!alreadyAdded) {
-        checkAndUpdateConversationRef.current();
-      }
+      checkAndUpdateConversationRef.current();
     });
 
     wsClient.on('llm_response_chunk', (data) => {
@@ -951,7 +866,6 @@ export function AppProvider({ children }: AppProviderProps) {
       // Clear any pending state
       dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
       pendingLLMResponseRef.current = null;
-      lastPendingTranscriptionRef.current = null;
     });
 
     wsClient.on('flashcards_generated', (flashcards) => {
@@ -1143,9 +1057,8 @@ export function AppProvider({ children }: AppProviderProps) {
         payload: { role: 'learner', content: trimmedText },
       });
 
-      // Track this as the last pending transcription so we don't duplicate it
-      // when the backend sends back the transcription event
-      lastPendingTranscriptionRef.current = trimmedText;
+      // Flag that this was a text message so we can ignore the transcription event
+      lastMessageWasTextRef.current = true;
 
       // Send to backend
       wsClient.send({ type: 'text_message', text: trimmedText });
@@ -1249,8 +1162,7 @@ export function AppProvider({ children }: AppProviderProps) {
       // Reset streaming state and clear pending flashcards (they belong to old conversation)
       dispatch({ type: 'RESET_STREAMING_STATE' });
       pendingLLMResponseRef.current = null;
-      lastPendingTranscriptionRef.current = null;
-      lastProcessedPairRef.current = null;
+      lastMessageWasTextRef.current = false;
       pendingFlashcardsRef.current = [];
 
       // Update the WebSocket with the loaded conversation
@@ -1319,8 +1231,7 @@ export function AppProvider({ children }: AppProviderProps) {
     dispatch({ type: 'RESET_CONVERSATION' });
     dispatch({ type: 'SET_FLASHCARDS', payload: [] });
     pendingLLMResponseRef.current = null;
-    lastPendingTranscriptionRef.current = null;
-    lastProcessedPairRef.current = null;
+    lastMessageWasTextRef.current = false;
     pendingFlashcardsRef.current = [];
 
     // Reset WebSocket conversation

From 7ba7aa9eb67d3a46fdae7d79b793ce7c9dddccd3 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 15:50:49 -0800
Subject: [PATCH 39/49] Revamped langauge handling to fix issues

---
 .../nodes/dialog-prompt-builder-node.ts       | 18 ++++++--
 backend/src/helpers/connection-manager.ts     | 16 ++++++++
 backend/src/prompts/conversation.njk          |  2 +-
 backend/src/services/websocket-handler.ts     | 38 ++++++++++++++++-
 frontend/src/context/AppContext.tsx           | 41 +++++++++++--------
 5 files changed, 91 insertions(+), 24 deletions(-)

diff --git a/backend/src/graphs/nodes/dialog-prompt-builder-node.ts b/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
index 637cc56..4503ada 100644
--- a/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
@@ -11,7 +11,10 @@
 import { CustomNode, GraphTypes, ProcessContext } from '@inworld/runtime/graph';
 import { PromptBuilder } from '@inworld/runtime/primitives/llm';
 import { ConnectionsMap, StateWithMemories } from '../../types/index.js';
-import { getLanguageConfig } from '../../config/languages.js';
+import {
+  getLanguageConfig,
+  DEFAULT_LANGUAGE_CODE,
+} from '../../config/languages.js';
 import { conversationTemplate } from '../../helpers/prompt-templates.js';
 import { graphLogger as logger } from '../../utils/logger.js';
 
@@ -29,12 +32,19 @@ export class DialogPromptBuilderNode extends CustomNode {
   }
 
   async process(
-    _context: ProcessContext,
+    context: ProcessContext,
     state: StateWithMemories
   ): Promise<GraphTypes.LLMChatRequest> {
+    // Ensure we have a valid language code
+    const languageCode = state.languageCode || DEFAULT_LANGUAGE_CODE;
+    if (!state.languageCode) {
+      const sessionId = context.getDatastore().get('sessionId') as string;
+      logger.warn({ sessionId }, 'missing_language_code_using_default');
+    }
+
     logger.debug(
       {
-        languageCode: state.languageCode || 'es',
+        languageCode,
         messageCount: state.messages?.length || 0,
         memoryCount: state.relevantMemories?.length || 0,
       },
@@ -42,7 +52,7 @@ export class DialogPromptBuilderNode extends CustomNode {
     );
 
     // Get language config from state
-    const langConfig = getLanguageConfig(state.languageCode || 'es');
+    const langConfig = getLanguageConfig(languageCode);
 
     // Build template variables from language config
     const templateVars = {
diff --git a/backend/src/helpers/connection-manager.ts b/backend/src/helpers/connection-manager.ts
index 2fc9f8a..cb4c364 100644
--- a/backend/src/helpers/connection-manager.ts
+++ b/backend/src/helpers/connection-manager.ts
@@ -813,9 +813,25 @@ export class ConnectionManager {
 
     const connection = this.connections[this.sessionId];
     if (connection) {
+      // Always update the connection state to ensure synchronization
       connection.state.languageCode = newLanguageCode;
       connection.state.targetLanguage = this.languageConfig.name;
       connection.state.voiceId = this.languageConfig.ttsConfig.speakerId;
+
+      this.logger.debug(
+        {
+          sessionId: this.sessionId,
+          languageCode: newLanguageCode,
+          targetLanguage: this.languageConfig.name,
+          voiceId: connection.state.voiceId,
+        },
+        'connection_state_language_updated'
+      );
+    } else {
+      this.logger.warn(
+        { sessionId: this.sessionId },
+        'connection_not_found_for_language_update'
+      );
     }
 
     this.logger.info(
diff --git a/backend/src/prompts/conversation.njk b/backend/src/prompts/conversation.njk
index e84733f..d797fc9 100644
--- a/backend/src/prompts/conversation.njk
+++ b/backend/src/prompts/conversation.njk
@@ -14,7 +14,7 @@
 - Use varied sentence structures
 - Generally, be terse, but expound if the user requests it
 - As the user's speech is being passed to you via speech-to-text, do your best to understand the user's intent even if there are transcription errors
-- Ask open-ended questions to prompt the user to practice their Spanish
+- Ask open-ended questions to prompt the user to practice their {{target_language}}
 {% if relevant_memories and relevant_memories|length > 0 %}
 
 # What You Remember About This User
diff --git a/backend/src/services/websocket-handler.ts b/backend/src/services/websocket-handler.ts
index de34304..0caac9e 100644
--- a/backend/src/services/websocket-handler.ts
+++ b/backend/src/services/websocket-handler.ts
@@ -257,6 +257,12 @@ function handleMessage(
       // Reset backend state when switching conversations
       connectionManager.reset();
       flashcardProcessors.get(connectionId)?.reset();
+      // Clear language in connectionAttributes so set_language will always process
+      const attrs = connectionAttributes.get(connectionId);
+      if (attrs) {
+        delete attrs.languageCode;
+        connectionAttributes.set(connectionId, attrs);
+      }
       logger.info({ connectionId }, 'conversation_context_reset');
     } else if (message.type === 'set_language') {
       handleLanguageChange(connectionId, ws, connectionManager, message);
@@ -315,12 +321,28 @@ function handleLanguageChange(
 
     const languageConfig = getLanguageConfig(newLanguageCode);
 
-    // Update all processors
+    // Update all processors FIRST to ensure they have the correct language
     flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
     feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
     memoryProcessors.get(connectionId)?.setLanguage(newLanguageCode);
+
+    // Update connection manager LAST - this updates the connection state
+    // which is used by the graph nodes
     connectionManager.setLanguage(newLanguageCode);
 
+    // Verify the language config matches what we set
+    const managerLanguageCode = connectionManager.getLanguageCode();
+    if (managerLanguageCode !== newLanguageCode) {
+      logger.error(
+        {
+          connectionId,
+          expected: newLanguageCode,
+          actual: managerLanguageCode,
+        },
+        'language_sync_error_connection_manager'
+      );
+    }
+
     // Reset conversation on language change
     connectionManager.reset();
     flashcardProcessors.get(connectionId)?.reset();
@@ -357,11 +379,23 @@ function handleUserContext(
   const userId = message.userId || message.data?.userId;
   const languageCode = message.languageCode || message.data?.languageCode;
   const currentAttrs = connectionAttributes.get(connectionId) || {};
+
+  // Only update languageCode if it hasn't been explicitly set via set_language
+  // This prevents user_context from overriding the language set for a conversation
+  // The language should be set via set_language when creating/switching conversations
+  const shouldUpdateLanguage =
+    languageCode &&
+    !currentAttrs.languageCode && // Only if not already set
+    languageCode !== DEFAULT_LANGUAGE_CODE; // And not just the default
+
   connectionAttributes.set(connectionId, {
     ...currentAttrs,
     timezone: timezone || currentAttrs.timezone,
     userId: userId || currentAttrs.userId,
-    languageCode: languageCode || currentAttrs.languageCode,
+    // Only set language if it hasn't been explicitly set and we have a valid code
+    languageCode: shouldUpdateLanguage
+      ? languageCode
+      : currentAttrs.languageCode,
   });
 
   // Set user ID on connection manager for memory retrieval
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 6a11858..b9b2f63 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -976,20 +976,12 @@ export function AppProvider({ children }: AppProviderProps) {
   }, [state.isRecording]);
 
   // Change language (only changes the current language for new conversations)
-  const changeLanguage = useCallback(
-    (newLanguage: string) => {
-      const storage = storageRef.current;
-      const wsClient = wsClientRef.current;
-
-      dispatch({ type: 'SET_LANGUAGE', payload: newLanguage });
-      storage.saveLanguage(newLanguage);
+  const changeLanguage = useCallback((newLanguage: string) => {
+    const storage = storageRef.current;
 
-      if (state.connectionStatus === 'connected') {
-        wsClient.send({ type: 'set_language', languageCode: newLanguage });
-      }
-    },
-    [state.connectionStatus]
-  );
+    dispatch({ type: 'SET_LANGUAGE', payload: newLanguage });
+    storage.saveLanguage(newLanguage);
+  }, []);
 
   // Send text message (bypasses audio/STT)
   const sendTextMessage = useCallback(
@@ -1218,14 +1210,21 @@ export function AppProvider({ children }: AppProviderProps) {
       );
     }
 
-    // Create new conversation
-    const newConversation = storage.createConversation(state.currentLanguage);
+    // Create new conversation with the current language preference
+    // Use state.currentLanguage directly since it's in the dependencies and will be up-to-date
+    const languageForNewConversation = state.currentLanguage;
+    const newConversation = storage.createConversation(
+      languageForNewConversation
+    );
     dispatch({ type: 'ADD_CONVERSATION', payload: newConversation });
     dispatch({
       type: 'SET_CURRENT_CONVERSATION_ID',
       payload: newConversation.id,
     });
-    storage.setCurrentConversationId(state.currentLanguage, newConversation.id);
+    storage.setCurrentConversationId(
+      languageForNewConversation,
+      newConversation.id
+    );
 
     // Clear chat and flashcards (new conversation has no flashcards)
     dispatch({ type: 'RESET_CONVERSATION' });
@@ -1234,9 +1233,17 @@ export function AppProvider({ children }: AppProviderProps) {
     lastMessageWasTextRef.current = false;
     pendingFlashcardsRef.current = [];
 
-    // Reset WebSocket conversation
+    // Reset and set language for new conversation
+    // We need to reset first, then set language to ensure the conversation starts fresh
+    // Even if the language is the same, we want to reset the conversation state
     if (state.connectionStatus === 'connected') {
+      // Reset the conversation context first
       wsClient.send({ type: 'conversation_context_reset' });
+      // Then set the language (this will also reset, but ensures language is correct)
+      wsClient.send({
+        type: 'set_language',
+        languageCode: languageForNewConversation,
+      });
     }
 
     // Close sidebar on mobile

From b7eaf4477f02c1635cda2b2f0dfb92c8c99b5fb8 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 15:55:35 -0800
Subject: [PATCH 40/49] Audio now interrupted when switching chats

---
 frontend/src/context/AppContext.tsx | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index b9b2f63..74e1c1a 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -1087,14 +1087,18 @@ export function AppProvider({ children }: AppProviderProps) {
       const storage = storageRef.current;
       const audioHandler = audioHandlerRef.current;
       const audioPlayer = audioPlayerRef.current;
+      const ttsAudioPlayer = ttsAudioPlayerRef.current;
       const wsClient = wsClientRef.current;
 
-      // Stop any ongoing recording/playback
+      // Stop any ongoing recording/playback and audio
       if (state.isRecording) {
         audioHandler.stopStreaming();
         dispatch({ type: 'SET_RECORDING', payload: false });
       }
+      // Stop main audio playback (TTS responses)
       audioPlayer.stop();
+      // Stop TTS audio playback (flashcard pronunciation)
+      ttsAudioPlayer.stop();
 
       // Save current conversation first if it exists
       if (
@@ -1184,14 +1188,18 @@ export function AppProvider({ children }: AppProviderProps) {
     const storage = storageRef.current;
     const audioHandler = audioHandlerRef.current;
     const audioPlayer = audioPlayerRef.current;
+    const ttsAudioPlayer = ttsAudioPlayerRef.current;
     const wsClient = wsClientRef.current;
 
-    // Stop any ongoing recording/playback
+    // Stop any ongoing recording/playback and audio
     if (state.isRecording) {
       audioHandler.stopStreaming();
       dispatch({ type: 'SET_RECORDING', payload: false });
     }
+    // Stop main audio playback (TTS responses)
     audioPlayer.stop();
+    // Stop TTS audio playback (flashcard pronunciation)
+    ttsAudioPlayer.stop();
 
     // Save current conversation first if it exists
     if (

From 5e624e9d16648621c717eeabdfaf1f248b04e170 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 8 Jan 2026 16:00:45 -0800
Subject: [PATCH 41/49] Fixed english flashcard audio not playing

---
 backend/src/config/languages.ts                        |  2 +-
 .../src/graphs/configs/flashcard-generation-graph.json | 10 +++++++---
 .../configs/lang-learning-conversation-graph.json      | 10 +++++++---
 .../src/graphs/configs/response-feedback-graph.json    | 10 +++++++---
 4 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/backend/src/config/languages.ts b/backend/src/config/languages.ts
index b742202..266a287 100644
--- a/backend/src/config/languages.ts
+++ b/backend/src/config/languages.ts
@@ -66,7 +66,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'en-US',
     ttsConfig: {
       speakerId: 'Ashley',
-      modelId: 'inworld-tts-1.5',
+      modelId: 'inworld-tts-1',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'en-US',
diff --git a/backend/src/graphs/configs/flashcard-generation-graph.json b/backend/src/graphs/configs/flashcard-generation-graph.json
index a73589e..7cb5d7b 100644
--- a/backend/src/graphs/configs/flashcard-generation-graph.json
+++ b/backend/src/graphs/configs/flashcard-generation-graph.json
@@ -70,8 +70,12 @@
         "to_node": "flashcard-parser"
       }
     ],
-    "end_nodes": ["flashcard-parser"],
-    "start_nodes": ["flashcard-prompt-builder"]
+    "end_nodes": [
+      "flashcard-parser"
+    ],
+    "start_nodes": [
+      "flashcard-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/src/graphs/configs/lang-learning-conversation-graph.json b/backend/src/graphs/configs/lang-learning-conversation-graph.json
index 311da8f..4c34e49 100644
--- a/backend/src/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/src/graphs/configs/lang-learning-conversation-graph.json
@@ -233,8 +233,12 @@
         "loop": true
       }
     ],
-    "end_nodes": ["tts-node-lang-learning"],
-    "start_nodes": ["audio-input-proxy-lang-learning"]
+    "end_nodes": [
+      "tts-node-lang-learning"
+    ],
+    "start_nodes": [
+      "audio-input-proxy-lang-learning"
+    ]
   },
   "components": [
     {
@@ -286,4 +290,4 @@
       "type": "custom-condition-from-interaction-queue-node-lang-learning-to-text-input-node-lang-learning"
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/backend/src/graphs/configs/response-feedback-graph.json b/backend/src/graphs/configs/response-feedback-graph.json
index d694a2b..978b019 100644
--- a/backend/src/graphs/configs/response-feedback-graph.json
+++ b/backend/src/graphs/configs/response-feedback-graph.json
@@ -70,8 +70,12 @@
         "to_node": "feedback-extractor"
       }
     ],
-    "end_nodes": ["feedback-extractor"],
-    "start_nodes": ["feedback-prompt-builder"]
+    "end_nodes": [
+      "feedback-extractor"
+    ],
+    "start_nodes": [
+      "feedback-prompt-builder"
+    ]
   },
   "components": [
     {
@@ -88,4 +92,4 @@
       }
     }
   ]
-}
+}
\ No newline at end of file

From d4c7397eb84707120fea0fcc5bdf18fbcd38fb35 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Wed, 14 Jan 2026 14:51:09 -0800
Subject: [PATCH 42/49] Fixed flashcard sizing

---
 frontend/src/styles/main.css | 43 +++++++++++++++++++++++++++++++-----
 1 file changed, 38 insertions(+), 5 deletions(-)

diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index ad4e431..280697a 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -1123,7 +1123,6 @@ body {
 
 .flashcard {
     position: relative;
-    height: 200px;
     min-height: 200px;
     cursor: pointer;
     perspective: 1000px;
@@ -1133,10 +1132,17 @@ body {
 .flashcard-inner {
     position: relative;
     width: 100%;
-    height: 100%;
     text-align: center;
     transition: transform 0.6s;
     transform-style: preserve-3d;
+    display: grid;
+    grid-template-columns: 1fr;
+    grid-template-rows: auto;
+}
+
+.flashcard-inner > * {
+    grid-column: 1;
+    grid-row: 1;
 }
 
 .flashcard.flipped .flashcard-inner {
@@ -1145,9 +1151,8 @@ body {
 
 .flashcard-front,
 .flashcard-back {
-    position: absolute;
     width: 100%;
-    height: 100%;
+    min-height: 200px;
     -webkit-backface-visibility: hidden;
     backface-visibility: hidden;
     border-radius: 12px;
@@ -1156,11 +1161,13 @@ body {
     flex-direction: column;
     justify-content: center;
     align-items: center;
+    box-sizing: border-box;
 }
 
 .flashcard-front {
     background: #f3f4f6;
     color: #1a1a1a;
+    overflow: hidden;
 }
 
 /* Pronounce button on flashcard */
@@ -1220,6 +1227,13 @@ body {
     background: #ffffff;
     border: 2px solid #e5e5e5;
     transform: rotateY(180deg);
+    justify-content: flex-start;
+    align-items: stretch;
+    overflow: hidden;
+}
+
+.flashcard-back > *:first-child {
+    margin-top: 0;
 }
 
 .flashcard-spanish,
@@ -1227,6 +1241,10 @@ body {
     font-size: 32px;
     font-weight: 700;
     text-align: center;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    hyphens: auto;
+    padding: 0 8px;
 }
 
 .flashcard-english {
@@ -1234,6 +1252,10 @@ body {
     font-weight: 600;
     color: #1a1a1a;
     margin-bottom: 16px;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    hyphens: auto;
+    flex-shrink: 0;
 }
 
 .flashcard-example {
@@ -1243,6 +1265,10 @@ body {
     margin-bottom: 16px;
     text-align: center;
     line-height: 1.4;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    hyphens: auto;
+    flex-shrink: 0;
 }
 
 .flashcard-mnemonic {
@@ -1252,7 +1278,14 @@ body {
     background: rgba(107, 114, 128, 0.08);
     border-radius: 8px;
     width: 100%;
-    text-align: center;
+    text-align: left;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    hyphens: auto;
+    flex-shrink: 0;
+    box-sizing: border-box;
+    line-height: 1.5;
+    margin-top: auto;
 }
 
 .mnemonic-label {

From 230ddb0fc9468e120f032cd32cc7b519443c0a99 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 15 Jan 2026 15:03:09 -0800
Subject: [PATCH 43/49] Fix conversation switching race conditions, add memory
 generation tracking, and improve UI language management

---
 backend/src/graphs/conversation-graph.ts      |   1 +
 .../nodes/dialog-prompt-builder-node.ts       |   2 +-
 .../graphs/nodes/tts-request-builder-node.ts  |   2 +-
 backend/src/graphs/simple-tts-graph.ts        |  21 +-
 backend/src/helpers/connection-manager.ts     | 290 ++++++++--
 backend/src/helpers/memory-processor.ts       |  16 +-
 backend/src/services/api-routes.ts            |   2 +-
 backend/src/services/graph-service.ts         |   4 +-
 backend/src/services/websocket-handler.ts     | 254 ++++++---
 backend/src/types/index.ts                    |   2 +
 frontend/src/App.tsx                          |  18 +-
 frontend/src/components/Flashcard.tsx         |  35 +-
 frontend/src/components/Sidebar.tsx           |  13 +-
 frontend/src/context/AppContext.tsx           | 515 ++++++++++++------
 frontend/src/services/AudioPlayer.ts          |   7 +
 frontend/src/services/Storage.ts              |  18 +
 frontend/src/services/WebSocketClient.ts      |  10 +-
 frontend/src/styles/main.css                  |  30 +-
 frontend/src/types/index.ts                   |   2 +
 19 files changed, 873 insertions(+), 369 deletions(-)

diff --git a/backend/src/graphs/conversation-graph.ts b/backend/src/graphs/conversation-graph.ts
index efd6b00..1c4f578 100644
--- a/backend/src/graphs/conversation-graph.ts
+++ b/backend/src/graphs/conversation-graph.ts
@@ -76,6 +76,7 @@ export class ConversationGraphWrapper {
       assemblyAIApiKey,
       defaultLanguageCode = DEFAULT_LANGUAGE_CODE,
     } = config;
+    // Use provided language code or default to Spanish
     const langConfig = getLanguageConfig(defaultLanguageCode);
     const postfix = `-lang-learning`;
 
diff --git a/backend/src/graphs/nodes/dialog-prompt-builder-node.ts b/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
index 4503ada..2d65bda 100644
--- a/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
+++ b/backend/src/graphs/nodes/dialog-prompt-builder-node.ts
@@ -35,7 +35,7 @@ export class DialogPromptBuilderNode extends CustomNode {
     context: ProcessContext,
     state: StateWithMemories
   ): Promise<GraphTypes.LLMChatRequest> {
-    // Ensure we have a valid language code
+    // Get language code from state, fallback to default
     const languageCode = state.languageCode || DEFAULT_LANGUAGE_CODE;
     if (!state.languageCode) {
       const sessionId = context.getDatastore().get('sessionId') as string;
diff --git a/backend/src/graphs/nodes/tts-request-builder-node.ts b/backend/src/graphs/nodes/tts-request-builder-node.ts
index 2c585c9..b1c5226 100644
--- a/backend/src/graphs/nodes/tts-request-builder-node.ts
+++ b/backend/src/graphs/nodes/tts-request-builder-node.ts
@@ -41,7 +41,7 @@ export class TTSRequestBuilderNode extends CustomNode {
   ): GraphTypes.TTSRequest {
     const sessionId = context.getDatastore().get('sessionId') as string;
 
-    // For long-running graphs, read voiceId from connection state at processing time
+    // Get voice from connection state (which is updated when language changes)
     const connection = this.connections[sessionId];
 
     // Get voice from state, or fall back to language config, or default
diff --git a/backend/src/graphs/simple-tts-graph.ts b/backend/src/graphs/simple-tts-graph.ts
index eaf2240..299b739 100644
--- a/backend/src/graphs/simple-tts-graph.ts
+++ b/backend/src/graphs/simple-tts-graph.ts
@@ -39,9 +39,11 @@ class TextExtractorNode extends CustomNode {
 /**
  * Creates a simple TTS graph for pronouncing words
  * RemoteTTSNode accepts String directly as input
+ * Language is hardcoded to Spanish
  */
 function createSimpleTTSGraph(languageCode: string): Graph {
-  const langConfig = getLanguageConfig(languageCode);
+  // Language is hardcoded to Spanish, ignore parameter
+  const langConfig = getLanguageConfig('es');
 
   logger.info(
     {
@@ -83,18 +85,17 @@ function createSimpleTTSGraph(languageCode: string): Graph {
   return graphBuilder.build();
 }
 
-// Cache for simple TTS graphs per language
-const simpleTTSGraphs: Map<string, Graph> = new Map();
+// Cache for simple TTS graph (always Spanish)
+let simpleTTSGraph: Graph | null = null;
 
 /**
- * Get or create a simple TTS graph for a language
+ * Get or create a simple TTS graph (always Spanish)
  */
 export function getSimpleTTSGraph(languageCode: string): Graph {
-  let graph = simpleTTSGraphs.get(languageCode);
-  if (!graph) {
-    logger.info({ languageCode }, 'creating_simple_tts_graph');
-    graph = createSimpleTTSGraph(languageCode);
-    simpleTTSGraphs.set(languageCode, graph);
+  // Language is hardcoded to Spanish, ignore parameter
+  if (!simpleTTSGraph) {
+    logger.info({ languageCode: 'es' }, 'creating_simple_tts_graph');
+    simpleTTSGraph = createSimpleTTSGraph('es');
   }
-  return graph;
+  return simpleTTSGraph;
 }
diff --git a/backend/src/helpers/connection-manager.ts b/backend/src/helpers/connection-manager.ts
index cb4c364..20867c1 100644
--- a/backend/src/helpers/connection-manager.ts
+++ b/backend/src/helpers/connection-manager.ts
@@ -34,6 +34,11 @@ export class ConnectionManager {
   private languageCode: string;
   private languageConfig: LanguageConfig;
   private logger: ReturnType<typeof createSessionLogger>;
+  private conversationId: string | null = null;
+  private pendingFlashcardGeneration: Promise<void> | null = null;
+  private pendingFeedbackGeneration: Promise<void> | null = null;
+  private pendingMemoryGeneration: Promise<void> | null = null;
+  private isSwitchingConversation: boolean = false;
   private restartAttempts = 0;
   private readonly MAX_RESTART_ATTEMPTS = 3;
   private lastRestartTime = 0;
@@ -53,9 +58,11 @@ export class ConnectionManager {
       ) => Promise<void>)
     | null = null;
 
-  // Callback for memory creation (non-blocking, fire-and-forget)
+  // Callback for memory creation
   private memoryCallback:
-    | ((messages: Array<{ role: string; content: string }>) => void)
+    | ((
+        messages: Array<{ role: string; content: string }>
+      ) => Promise<void>)
     | null = null;
 
   // User ID for memory retrieval/creation
@@ -76,6 +83,7 @@ export class ConnectionManager {
     this.ws = ws;
     this.graphWrapper = graphWrapper;
     this.connections = connections;
+    // Default language is Spanish, but can be changed via conversation_switch
     this.languageCode = languageCode;
     this.languageConfig = getLanguageConfig(languageCode);
     this.multimodalStreamManager = new MultimodalStreamManager();
@@ -89,9 +97,10 @@ export class ConnectionManager {
         messages: [],
         userName: '',
         targetLanguage: this.languageConfig.name,
-        languageCode: languageCode,
+        languageCode: this.languageCode,
         voiceId: this.languageConfig.ttsConfig.speakerId,
         output_modalities: ['audio', 'text'],
+        conversationId: undefined,
       },
       multimodalStreamManager: this.multimodalStreamManager,
       onSpeechDetected: (interactionId) =>
@@ -301,6 +310,7 @@ export class ConnectionManager {
             this.sendToClient({
               type: 'transcription',
               text: transcription.trim(),
+              conversationId: this.conversationId,
               timestamp: Date.now(),
             });
           }
@@ -325,6 +335,7 @@ export class ConnectionManager {
             this.sendToClient({
               type: 'transcription',
               text: transcription.trim(),
+              conversationId: this.conversationId,
               timestamp: Date.now(),
             });
           }
@@ -353,6 +364,7 @@ export class ConnectionManager {
               this.sendToClient({
                 type: 'llm_response_chunk',
                 text: chunk.text,
+                conversationId: this.conversationId,
                 timestamp: Date.now(),
               });
             }
@@ -370,6 +382,7 @@ export class ConnectionManager {
               this.sendToClient({
                 type: 'llm_response_complete',
                 text: llmResponse.trim(),
+                conversationId: this.conversationId,
                 timestamp: Date.now(),
               });
             }
@@ -411,6 +424,12 @@ export class ConnectionManager {
                 );
               }
 
+              // Block audio during conversation switch
+              if (this.isSwitchingConversation) {
+                this.logger.debug('blocking_audio_during_conversation_switch');
+                continue;
+              }
+
               // Convert audio to base64 for WebSocket transmission
               // Use ttsSampleRate as fallback (not inputSampleRate which is for microphone input)
               const audioResult = this.convertAudioToBase64(chunk.audio);
@@ -423,6 +442,7 @@ export class ConnectionManager {
                     chunk.audio.sampleRate || serverConfig.audio.ttsSampleRate,
                   text: chunk.text || '',
                   isFirstChunk: isFirstChunk,
+                  conversationId: this.conversationId,
                   timestamp: Date.now(),
                 });
                 isFirstChunk = false;
@@ -430,24 +450,25 @@ export class ConnectionManager {
             }
           }
 
-          // Mark processing complete (even if interrupted)
-          this.markProcessingComplete();
-
           // Only send completion signals if not interrupted
           if (!wasInterrupted) {
-            // Send completion signal
-            this.logger.debug('tts_stream_complete');
-            this.sendToClient({
-              type: 'audio_stream_complete',
-              timestamp: Date.now(),
-            });
+            // Send completion signals
+            if (!this.isSwitchingConversation) {
+              this.logger.debug('tts_stream_complete');
+              this.sendToClient({
+                type: 'audio_stream_complete',
+                conversationId: this.conversationId,
+                timestamp: Date.now(),
+              });
 
-            // Send conversation update
-            this.sendToClient({
-              type: 'conversation_update',
-              messages: connection.state.messages,
-              timestamp: Date.now(),
-            });
+              // Send conversation update with conversationId
+              this.sendToClient({
+                type: 'conversation_update',
+                messages: connection.state.messages,
+                conversationId: this.conversationId,
+                timestamp: Date.now(),
+              });
+            }
 
             // Trigger flashcard, feedback, and memory generation after TTS completes
             this.triggerFlashcardGeneration();
@@ -456,6 +477,7 @@ export class ConnectionManager {
           } else {
             this.logger.debug('tts_interrupted_skipping_completion');
           }
+          this.markProcessingComplete();
         },
 
         // Handle errors
@@ -517,6 +539,7 @@ export class ConnectionManager {
       this.sendToClient({
         type: 'interrupt',
         reason: 'continuation_detected',
+        conversationId: this.conversationId,
         timestamp: Date.now(),
       });
     } else {
@@ -524,6 +547,7 @@ export class ConnectionManager {
       this.sendToClient({
         type: 'interrupt',
         reason: 'speech_start',
+        conversationId: this.conversationId,
         timestamp: Date.now(),
       });
     }
@@ -533,6 +557,7 @@ export class ConnectionManager {
       type: 'speech_detected',
       interactionId,
       data: { text: '' },
+      conversationId: this.conversationId,
       timestamp: Date.now(),
     });
   }
@@ -545,6 +570,7 @@ export class ConnectionManager {
       type: 'partial_transcript',
       text,
       interactionId,
+      conversationId: this.conversationId,
       timestamp: Date.now(),
     });
   }
@@ -600,6 +626,7 @@ export class ConnectionManager {
           type: 'conversation_rollback',
           removedCount,
           messages: messages,
+          conversationId: this.conversationId,
           timestamp: Date.now(),
         });
       }
@@ -681,9 +708,14 @@ export class ConnectionManager {
       content: m.content,
     }));
 
-    this.flashcardCallback(recentMessages).catch((error) => {
-      this.logger.error({ err: error }, 'flashcard_generation_trigger_error');
-    });
+    // Track pending flashcard generation
+    this.pendingFlashcardGeneration = this.flashcardCallback(recentMessages)
+      .catch((error) => {
+        this.logger.error({ err: error }, 'flashcard_generation_trigger_error');
+      })
+      .finally(() => {
+        this.pendingFlashcardGeneration = null;
+      });
   }
 
   /**
@@ -708,15 +740,21 @@ export class ConnectionManager {
       content: m.content,
     }));
 
-    this.feedbackCallback(recentMessages, lastUserMessage.content).catch(
-      (error) => {
+    // Track pending feedback generation
+    this.pendingFeedbackGeneration = this.feedbackCallback(
+      recentMessages,
+      lastUserMessage.content
+    )
+      .catch((error) => {
         this.logger.error({ err: error }, 'feedback_generation_trigger_error');
-      }
-    );
+      })
+      .finally(() => {
+        this.pendingFeedbackGeneration = null;
+      });
   }
 
   /**
-   * Trigger memory generation (non-blocking, fire-and-forget)
+   * Trigger memory generation
    * The callback handles turn counting and decides whether to create a memory
    */
   private triggerMemoryGeneration(): void {
@@ -730,8 +768,14 @@ export class ConnectionManager {
       content: m.content,
     }));
 
-    // Fire and forget - the callback is synchronous and handles async internally
-    this.memoryCallback(recentMessages);
+    // Track pending memory generation
+    this.pendingMemoryGeneration = this.memoryCallback(recentMessages)
+      .catch((error) => {
+        this.logger.error({ err: error }, 'memory_generation_trigger_error');
+      })
+      .finally(() => {
+        this.pendingMemoryGeneration = null;
+      });
   }
 
   // ============================================================
@@ -756,7 +800,9 @@ export class ConnectionManager {
   }
 
   setMemoryCallback(
-    callback: (messages: Array<{ role: string; content: string }>) => void
+    callback: (
+      messages: Array<{ role: string; content: string }>
+    ) => Promise<void>
   ): void {
     this.memoryCallback = callback;
   }
@@ -798,46 +844,25 @@ export class ConnectionManager {
   }
 
   /**
-   * Change language for this session
+   * Update language for this connection
    */
-  setLanguage(newLanguageCode: string): void {
-    if (this.languageCode === newLanguageCode) return;
+  setLanguage(languageCode: string): void {
+    if (this.languageCode === languageCode) return;
 
     this.logger.info(
-      { from: this.languageCode, to: newLanguageCode },
+      { from: this.languageCode, to: languageCode },
       'changing_language'
     );
 
-    this.languageCode = newLanguageCode;
-    this.languageConfig = getLanguageConfig(newLanguageCode);
+    this.languageCode = languageCode;
+    this.languageConfig = getLanguageConfig(languageCode);
 
     const connection = this.connections[this.sessionId];
     if (connection) {
-      // Always update the connection state to ensure synchronization
-      connection.state.languageCode = newLanguageCode;
+      connection.state.languageCode = languageCode;
       connection.state.targetLanguage = this.languageConfig.name;
       connection.state.voiceId = this.languageConfig.ttsConfig.speakerId;
-
-      this.logger.debug(
-        {
-          sessionId: this.sessionId,
-          languageCode: newLanguageCode,
-          targetLanguage: this.languageConfig.name,
-          voiceId: connection.state.voiceId,
-        },
-        'connection_state_language_updated'
-      );
-    } else {
-      this.logger.warn(
-        { sessionId: this.sessionId },
-        'connection_not_found_for_language_update'
-      );
     }
-
-    this.logger.info(
-      { language: this.languageConfig.name },
-      'language_changed'
-    );
   }
 
   /**
@@ -852,6 +877,157 @@ export class ConnectionManager {
     this.logger.info('conversation_reset');
   }
 
+  /**
+   * Load conversation history from client
+   * Called when switching to an existing conversation
+   */
+  loadConversationHistory(
+    messages: Array<{ role: string; content: string; timestamp?: string }>
+  ): void {
+    const connection = this.connections[this.sessionId];
+    if (!connection) {
+      this.logger.warn('connection_not_found_for_history_load');
+      return;
+    }
+
+    // Convert client messages to backend format
+    const chatMessages = messages.map((m, index) => ({
+      id: `msg_${Date.now()}_${index}_${Math.random().toString(36).substring(2, 9)}`,
+      role: m.role as 'user' | 'assistant' | 'system',
+      content: m.content,
+      timestamp: m.timestamp || new Date().toISOString(),
+    }));
+
+    connection.state.messages = chatMessages;
+    
+    this.logger.info(
+      { messageCount: chatMessages.length },
+      'conversation_history_loaded'
+    );
+  }
+
+  /**
+   * Wait for all pending operations to complete
+   * Used before switching conversations
+   */
+  async waitForPendingOperations(): Promise<void> {
+    // FIRST: Wait for graph processing to complete (isProcessingResponse becomes false)
+    // This ensures flashcard/feedback generation has been triggered before we check for them
+    if (this.isProcessingResponse) {
+      this.logger.info('waiting_for_graph_processing_to_complete');
+      await new Promise<void>((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (!this.isProcessingResponse) {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+
+        // Timeout after 5 seconds
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve();
+        }, 5000);
+      });
+      this.logger.info('graph_processing_completed');
+    }
+
+    // SECOND: After graph processing completes, check for pending flashcard/feedback/memory generation
+    // By this point, triggerFlashcardGeneration(), triggerFeedbackGeneration(), and triggerMemoryGeneration() have been called
+    const promises: Promise<void>[] = [];
+
+    if (this.pendingFlashcardGeneration) {
+      this.logger.info('waiting_for_flashcard_generation');
+      promises.push(this.pendingFlashcardGeneration);
+    }
+
+    if (this.pendingFeedbackGeneration) {
+      this.logger.info('waiting_for_feedback_generation');
+      promises.push(this.pendingFeedbackGeneration);
+    }
+
+    if (this.pendingMemoryGeneration) {
+      this.logger.info('waiting_for_memory_generation');
+      promises.push(this.pendingMemoryGeneration);
+    }
+
+    if (promises.length > 0) {
+      this.logger.info(
+        { pendingCount: promises.length },
+        'waiting_for_pending_operations'
+      );
+      await Promise.all(promises);
+      this.logger.info('pending_operations_completed');
+    }
+  }
+
+  /**
+   * Switch to a new conversation
+   * Waits for pending operations, then updates language, history, and conversationId
+   */
+  async switchConversation(
+    conversationId: string,
+    languageCode: string,
+    messages: Array<{ role: string; content: string; timestamp?: string }>
+  ): Promise<void> {
+    if (this.isSwitchingConversation) {
+      this.logger.warn('conversation_switch_already_in_progress');
+      return;
+    }
+
+    this.isSwitchingConversation = true;
+    this.logger.info(
+      { conversationId, languageCode, messageCount: messages.length },
+      'switching_conversation'
+    );
+
+    try {
+      // Wait for pending operations to complete
+      await this.waitForPendingOperations();
+
+      // Update language
+      const newLanguageConfig = getLanguageConfig(languageCode);
+      this.languageCode = languageCode;
+      this.languageConfig = newLanguageConfig;
+
+      // Update connection state
+      const connection = this.connections[this.sessionId];
+      if (connection) {
+        connection.state.languageCode = languageCode;
+        connection.state.targetLanguage = newLanguageConfig.name;
+        connection.state.voiceId = newLanguageConfig.ttsConfig.speakerId;
+        connection.state.conversationId = conversationId;
+
+        // Load conversation history
+        const chatMessages = messages.map((m, index) => ({
+          id: `msg_${Date.now()}_${index}_${Math.random().toString(36).substring(2, 9)}`,
+          role: m.role as 'user' | 'assistant' | 'system',
+          content: m.content,
+          timestamp: m.timestamp || new Date().toISOString(),
+        }));
+
+        connection.state.messages = chatMessages;
+      }
+
+      // Update conversationId
+      this.conversationId = conversationId;
+
+      this.logger.info(
+        { conversationId, languageCode, messageCount: messages.length },
+        'conversation_switched'
+      );
+    } finally {
+      this.isSwitchingConversation = false;
+    }
+  }
+
+  /**
+   * Get current conversation ID
+   */
+  getConversationId(): string | null {
+    return this.conversationId;
+  }
+
   /**
    * Send a text message (bypasses audio/STT, goes directly to LLM)
    */
diff --git a/backend/src/helpers/memory-processor.ts b/backend/src/helpers/memory-processor.ts
index 32aa2a4..e09ed5f 100644
--- a/backend/src/helpers/memory-processor.ts
+++ b/backend/src/helpers/memory-processor.ts
@@ -127,17 +127,19 @@ export class MemoryProcessor {
   }
 
   /**
-   * Non-blocking memory creation (fire-and-forget)
-   * Call this without awaiting to not block the conversation
+   * Asynchronous Memory creation 
    */
-  createMemoryAsync(
+  async createMemoryAsync(
     userId: string,
     messages: Array<{ role: string; content: string }>
-  ): void {
-    // Fire and forget - don't await in calling code
-    this.processMemoryCreation(userId, messages).catch((error) => {
+  ): Promise<void> {
+    // Wait for memory creation to complete
+    try {
+      await this.processMemoryCreation(userId, messages);
+    } catch (error) {
       logger.error({ err: error }, 'memory_creation_failed');
-    });
+      throw error; // Re-throw so caller can handle it
+    }
   }
 
   /**
diff --git a/backend/src/services/api-routes.ts b/backend/src/services/api-routes.ts
index 4350085..ab1a7a6 100644
--- a/backend/src/services/api-routes.ts
+++ b/backend/src/services/api-routes.ts
@@ -32,7 +32,7 @@ apiRouter.post('/export-anki', async (req, res) => {
       return;
     }
 
-    const defaultDeckName = `Inworld Language Tutor ${languageCode || 'Language'} Cards`;
+    const defaultDeckName = `Inworld Language Tutor Spanish Cards`;
     const apkgBuffer = await exporter.exportFlashcards(
       flashcards,
       deckName || defaultDeckName
diff --git a/backend/src/services/graph-service.ts b/backend/src/services/graph-service.ts
index 741ef14..032e393 100644
--- a/backend/src/services/graph-service.ts
+++ b/backend/src/services/graph-service.ts
@@ -16,7 +16,7 @@ import {
 } from '../graphs/conversation-graph.js';
 import { getFlashcardGraph } from '../graphs/flashcard-graph.js';
 import { getResponseFeedbackGraph } from '../graphs/response-feedback-graph.js';
-import { DEFAULT_LANGUAGE_CODE } from '../config/languages.js';
+// Language is hardcoded to Spanish
 import { serverLogger as logger } from '../utils/logger.js';
 import { connections } from './state.js';
 
@@ -40,7 +40,7 @@ export async function initializeGraph(): Promise<void> {
   graphWrapper = getConversationGraph({
     assemblyAIApiKey,
     connections,
-    defaultLanguageCode: DEFAULT_LANGUAGE_CODE,
+    defaultLanguageCode: 'es', // Always Spanish
   });
   logger.info('conversation_graph_initialized');
 }
diff --git a/backend/src/services/websocket-handler.ts b/backend/src/services/websocket-handler.ts
index 0caac9e..1da75e8 100644
--- a/backend/src/services/websocket-handler.ts
+++ b/backend/src/services/websocket-handler.ts
@@ -13,7 +13,6 @@ import { FlashcardProcessor } from '../helpers/flashcard-processor.js';
 import { FeedbackProcessor } from '../helpers/feedback-processor.js';
 import { MemoryProcessor } from '../helpers/memory-processor.js';
 import {
-  getLanguageConfig,
   getSupportedLanguageCodes,
   DEFAULT_LANGUAGE_CODE,
 } from '../config/languages.js';
@@ -44,8 +43,8 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
     const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
     logger.info({ connectionId }, 'websocket_connected');
 
-    // Default language is Spanish
-    const defaultLanguageCode = DEFAULT_LANGUAGE_CODE;
+    // Default language is Spanish, but can be changed via conversation_switch
+    const languageCode = DEFAULT_LANGUAGE_CODE;
 
     // Create connection manager (replaces AudioProcessor)
     const connectionManager = new ConnectionManager(
@@ -53,17 +52,17 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
       ws,
       graphWrapper,
       connections,
-      defaultLanguageCode
+      languageCode
     );
 
     // Create flashcard processor
-    const flashcardProcessor = new FlashcardProcessor(defaultLanguageCode);
+    const flashcardProcessor = new FlashcardProcessor(languageCode);
 
     // Create feedback processor
-    const feedbackProcessor = new FeedbackProcessor(defaultLanguageCode);
+    const feedbackProcessor = new FeedbackProcessor(languageCode);
 
     // Create memory processor
-    const memoryProcessor = new MemoryProcessor(defaultLanguageCode);
+    const memoryProcessor = new MemoryProcessor(languageCode);
 
     // Store processors
     connectionManagers.set(connectionId, connectionManager);
@@ -71,7 +70,7 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
     feedbackProcessors.set(connectionId, feedbackProcessor);
     memoryProcessors.set(connectionId, memoryProcessor);
     connectionAttributes.set(connectionId, {
-      languageCode: defaultLanguageCode,
+      languageCode: languageCode,
     });
 
     // Set up flashcard generation callback
@@ -102,10 +101,12 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
           userContext
         );
         if (flashcards.length > 0) {
+          const conversationId = connectionManager.getConversationId();
           ws.send(
             JSON.stringify({
               type: 'flashcards_generated',
               flashcards,
+              conversationId: conversationId || null,
             })
           );
         }
@@ -149,11 +150,13 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
           );
 
           if (feedback) {
+            const conversationId = connectionManager.getConversationId();
             ws.send(
               JSON.stringify({
                 type: 'feedback_generated',
                 messageContent: currentTranscript,
                 feedback,
+                conversationId: conversationId || null,
               })
             );
           }
@@ -168,8 +171,8 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
       }
     );
 
-    // Set up memory generation callback (fire-and-forget)
-    connectionManager.setMemoryCallback((messages) => {
+    // Set up memory generation callback
+    connectionManager.setMemoryCallback(async (messages) => {
       if (isShuttingDown()) {
         return;
       }
@@ -186,8 +189,8 @@ export function setupWebSocketHandlers(wss: WebSocketServer): void {
       memoryProcessor.incrementTurn();
 
       if (memoryProcessor.shouldCreateMemory()) {
-        // Fire and forget - createMemoryAsync handles errors internally
-        memoryProcessor.createMemoryAsync(userId, messages);
+        // Wait for memory creation to complete
+        await memoryProcessor.createMemoryAsync(userId, messages);
       }
     });
 
@@ -257,15 +260,11 @@ function handleMessage(
       // Reset backend state when switching conversations
       connectionManager.reset();
       flashcardProcessors.get(connectionId)?.reset();
-      // Clear language in connectionAttributes so set_language will always process
-      const attrs = connectionAttributes.get(connectionId);
-      if (attrs) {
-        delete attrs.languageCode;
-        connectionAttributes.set(connectionId, attrs);
-      }
       logger.info({ connectionId }, 'conversation_context_reset');
-    } else if (message.type === 'set_language') {
-      handleLanguageChange(connectionId, ws, connectionManager, message);
+    } else if (message.type === 'conversation_update') {
+      handleConversationUpdate(connectionId, connectionManager, message);
+    } else if (message.type === 'conversation_switch') {
+      handleConversationSwitch(connectionId, ws, connectionManager, message);
     } else if (message.type === 'user_context') {
       handleUserContext(connectionId, message);
     } else if (message.type === 'flashcard_clicked') {
@@ -285,83 +284,171 @@ function handleMessage(
   }
 }
 
-function handleLanguageChange(
+function handleConversationUpdate(
   connectionId: string,
-  ws: WebSocket,
   connectionManager: ConnectionManager,
-  message: { languageCode?: string }
+  message: {
+    data?: {
+      messages?: Array<{ role: string; content: string; timestamp?: string }>;
+    };
+    messages?: Array<{ role: string; content: string; timestamp?: string }>;
+  }
 ): void {
-  const requestedCode = message.languageCode;
+  // Handle both formats: { data: { messages: [...] } } and { messages: [...] }
+  const messages =
+    message.messages || message.data?.messages || (message.data as any)?.messages;
+
+  if (!messages || !Array.isArray(messages)) {
+    logger.debug(
+      { connectionId, hasData: !!message.data, hasMessages: !!message.messages },
+      'conversation_update_missing_or_invalid_messages'
+    );
+    return;
+  }
+
+  logger.info(
+    { connectionId, messageCount: messages.length },
+    'loading_conversation_history'
+  );
+
+  try {
+    connectionManager.loadConversationHistory(messages);
+    logger.info(
+      { connectionId, messageCount: messages.length },
+      'conversation_history_loaded'
+    );
+  } catch (error) {
+    logger.error(
+      { err: error, connectionId },
+      'failed_to_load_conversation_history'
+    );
+  }
+}
+
+async function handleConversationSwitch(
+  connectionId: string,
+  ws: WebSocket,
+  connectionManager: ConnectionManager,
+  message: {
+    conversationId?: string;
+    languageCode?: string;
+    messages?: Array<{ role: string; content: string; timestamp?: string }>;
+    data?: {
+      conversationId?: string;
+      languageCode?: string;
+      messages?: Array<{ role: string; content: string; timestamp?: string }>;
+    };
+  }
+): Promise<void> {
+  const conversationId =
+    message.conversationId || message.data?.conversationId;
+  const requestedLanguageCode = message.languageCode || message.data?.languageCode;
+  const messages = message.messages || message.data?.messages;
+
+  if (!conversationId || !requestedLanguageCode) {
+    logger.warn(
+      { connectionId, hasConversationId: !!conversationId, hasLanguageCode: !!requestedLanguageCode },
+      'conversation_switch_missing_required_fields'
+    );
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        message: 'Missing conversationId or languageCode',
+        timestamp: Date.now(),
+      })
+    );
+    return;
+  }
+
+  if (!messages || !Array.isArray(messages)) {
+    logger.warn({ connectionId }, 'conversation_switch_missing_messages');
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        message: 'Missing messages array',
+        timestamp: Date.now(),
+      })
+    );
+    return;
+  }
+
+  // Validate language code
   const supportedCodes = getSupportedLanguageCodes();
+  const languageCode = supportedCodes.includes(requestedLanguageCode)
+    ? requestedLanguageCode
+    : DEFAULT_LANGUAGE_CODE;
 
-  let newLanguageCode = DEFAULT_LANGUAGE_CODE;
-  if (requestedCode && supportedCodes.includes(requestedCode)) {
-    newLanguageCode = requestedCode;
-  } else if (requestedCode) {
+  if (requestedLanguageCode !== languageCode) {
     logger.warn(
       {
         connectionId,
-        invalidCode: requestedCode,
-        fallback: DEFAULT_LANGUAGE_CODE,
+        requestedCode: requestedLanguageCode,
+        fallback: languageCode,
       },
-      'invalid_language_code_using_default'
+      'invalid_language_code_using_fallback'
     );
   }
 
-  const attrs = connectionAttributes.get(connectionId) || {};
+  logger.info(
+    {
+      connectionId,
+      conversationId,
+      languageCode,
+      messageCount: messages.length,
+    },
+    'conversation_switch_requested'
+  );
 
-  if (attrs.languageCode !== newLanguageCode) {
-    logger.info(
-      { connectionId, from: attrs.languageCode, to: newLanguageCode },
-      'language_change'
+  try {
+    // Switch conversation (waits for pending operations FIRST)
+    // This ensures any flashcard/feedback generation in progress uses the OLD language
+    await connectionManager.switchConversation(
+      conversationId,
+      languageCode,
+      messages
     );
 
-    attrs.languageCode = newLanguageCode;
-    connectionAttributes.set(connectionId, attrs);
-
-    const languageConfig = getLanguageConfig(newLanguageCode);
-
-    // Update all processors FIRST to ensure they have the correct language
-    flashcardProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-    feedbackProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-    memoryProcessors.get(connectionId)?.setLanguage(newLanguageCode);
-
-    // Update connection manager LAST - this updates the connection state
-    // which is used by the graph nodes
-    connectionManager.setLanguage(newLanguageCode);
-
-    // Verify the language config matches what we set
-    const managerLanguageCode = connectionManager.getLanguageCode();
-    if (managerLanguageCode !== newLanguageCode) {
-      logger.error(
-        {
-          connectionId,
-          expected: newLanguageCode,
-          actual: managerLanguageCode,
-        },
-        'language_sync_error_connection_manager'
-      );
-    }
+    // Update processors with new language AFTER pending operations complete
+    // This ensures flashcard generation for the old conversation uses the old language
+    const flashcardProcessor = flashcardProcessors.get(connectionId);
+    const feedbackProcessor = feedbackProcessors.get(connectionId);
+    const memoryProcessor = memoryProcessors.get(connectionId);
 
-    // Reset conversation on language change
-    connectionManager.reset();
-    flashcardProcessors.get(connectionId)?.reset();
-    feedbackProcessors.get(connectionId)?.reset();
-    memoryProcessors.get(connectionId)?.reset();
+    if (flashcardProcessor) {
+      flashcardProcessor.setLanguage(languageCode);
+    }
+    if (feedbackProcessor) {
+      feedbackProcessor.setLanguage(languageCode);
+    }
+    if (memoryProcessor) {
+      memoryProcessor.setLanguage(languageCode);
+    }
 
-    // Send confirmation
+    // Send ready signal
     ws.send(
       JSON.stringify({
-        type: 'language_changed',
-        languageCode: newLanguageCode,
-        languageName: languageConfig.name,
-        teacherName: languageConfig.teacherPersona.name,
+        type: 'conversation_ready',
+        conversationId,
+        languageCode,
+        timestamp: Date.now(),
       })
     );
 
     logger.info(
-      { connectionId, language: languageConfig.name },
-      'language_changed'
+      { connectionId, conversationId, languageCode },
+      'conversation_switch_complete'
+    );
+  } catch (error) {
+    logger.error(
+      { err: error, connectionId, conversationId },
+      'conversation_switch_error'
+    );
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        message: 'Failed to switch conversation',
+        timestamp: Date.now(),
+      })
     );
   }
 }
@@ -377,25 +464,14 @@ function handleUserContext(
 ): void {
   const timezone = message.timezone || message.data?.timezone;
   const userId = message.userId || message.data?.userId;
-  const languageCode = message.languageCode || message.data?.languageCode;
   const currentAttrs = connectionAttributes.get(connectionId) || {};
 
-  // Only update languageCode if it hasn't been explicitly set via set_language
-  // This prevents user_context from overriding the language set for a conversation
-  // The language should be set via set_language when creating/switching conversations
-  const shouldUpdateLanguage =
-    languageCode &&
-    !currentAttrs.languageCode && // Only if not already set
-    languageCode !== DEFAULT_LANGUAGE_CODE; // And not just the default
-
+  // Language is hardcoded to Spanish, ignore any languageCode from client
   connectionAttributes.set(connectionId, {
     ...currentAttrs,
     timezone: timezone || currentAttrs.timezone,
     userId: userId || currentAttrs.userId,
-    // Only set language if it hasn't been explicitly set and we have a valid code
-    languageCode: shouldUpdateLanguage
-      ? languageCode
-      : currentAttrs.languageCode,
+    languageCode: 'es', // Always Spanish
   });
 
   // Set user ID on connection manager for memory retrieval
@@ -434,7 +510,7 @@ function handleFlashcardClicked(
       english: card.english || card.translation || '',
       source: 'ui',
       timezone: attrs.timezone || '',
-      languageCode: attrs.languageCode || DEFAULT_LANGUAGE_CODE,
+      languageCode: 'es',
     });
   } catch (error) {
     logger.error({ err: error, connectionId }, 'flashcard_click_record_error');
@@ -502,7 +578,7 @@ async function handleTTSPronounce(
   message: { text?: string; languageCode?: string }
 ): Promise<void> {
   const text = message.text;
-  const languageCode = message.languageCode || DEFAULT_LANGUAGE_CODE;
+  const languageCode = 'es'; // Always Spanish
 
   if (typeof text !== 'string' || text.trim().length === 0) {
     ws.send(
diff --git a/backend/src/types/index.ts b/backend/src/types/index.ts
index beed25d..4f43dda 100644
--- a/backend/src/types/index.ts
+++ b/backend/src/types/index.ts
@@ -32,6 +32,8 @@ export interface State {
   output_modalities: ('text' | 'audio')[];
   // User ID for memory retrieval/creation (optional - anonymous users won't have this)
   userId?: string;
+  // Conversation ID for routing responses to the correct conversation
+  conversationId?: string;
 }
 
 /**
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 22e6ddd..34f4f93 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,4 +1,4 @@
-import { AppProvider } from './context/AppContext';
+import { AppProvider, useApp } from './context/AppContext';
 import { Header } from './components/Header';
 import { Sidebar } from './components/Sidebar';
 import { ChatSection } from './components/ChatSection';
@@ -6,6 +6,9 @@ import { FlashcardsSection } from './components/FlashcardsSection';
 import './styles/main.css';
 
 function AppContent() {
+  const { state } = useApp();
+  const { switchingConversation } = state;
+
   return (
     <div className="app-wrapper">
       <Header />
@@ -15,8 +18,17 @@ function AppContent() {
           <main className="main">
             <div className="container">
               <div className="app-grid">
-                <ChatSection />
-                <FlashcardsSection />
+                {switchingConversation ? (
+                  <div className="conversation-switch-loading">
+                    <div className="chat-loading-spinner" />
+                    <div className="chat-loading-text">Switching conversation...</div>
+                  </div>
+                ) : (
+                  <>
+                    <ChatSection />
+                    <FlashcardsSection />
+                  </>
+                )}
               </div>
             </div>
           </main>
diff --git a/frontend/src/components/Flashcard.tsx b/frontend/src/components/Flashcard.tsx
index ab81bc3..31923ee 100644
--- a/frontend/src/components/Flashcard.tsx
+++ b/frontend/src/components/Flashcard.tsx
@@ -8,10 +8,9 @@ interface FlashcardProps {
   isPronouncing?: boolean;
 }
 
-function escapeHtml(text: string): string {
-  const div = document.createElement('div');
-  div.textContent = text;
-  return div.innerHTML;
+function capitalizeFirstLetter(text: string): string {
+  if (!text) return text;
+  return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
 export function Flashcard({
@@ -42,6 +41,9 @@ export function Flashcard({
   const example = flashcard.example || flashcard.example_sentence || '';
   const mnemonic = flashcard.mnemonic || '';
 
+  // Capitalize the first letter of the target word for display
+  const displayTargetWord = capitalizeFirstLetter(targetWord);
+
   return (
     <div
       className={`flashcard ${isFlipped ? 'flipped' : ''}`}
@@ -49,10 +51,9 @@ export function Flashcard({
     >
       <div className="flashcard-inner">
         <div className="flashcard-front">
-          <div
-            className="flashcard-target-word"
-            dangerouslySetInnerHTML={{ __html: escapeHtml(targetWord) }}
-          />
+          <div className="flashcard-target-word">
+            {displayTargetWord}
+          </div>
           <button
             className={`pronounce-button ${isPronouncing ? 'loading' : ''}`}
             onClick={handlePronounce}
@@ -78,20 +79,16 @@ export function Flashcard({
           </button>
         </div>
         <div className="flashcard-back">
-          <div
-            className="flashcard-english"
-            dangerouslySetInnerHTML={{ __html: escapeHtml(english) }}
-          />
-          <div
-            className="flashcard-example"
-            dangerouslySetInnerHTML={{ __html: escapeHtml(example) }}
-          />
+          <div className="flashcard-english">
+            {english}
+          </div>
+          <div className="flashcard-example">
+            {example}
+          </div>
           {mnemonic && (
             <div className="flashcard-mnemonic">
               <span className="mnemonic-label">Remember:</span>{' '}
-              <span
-                dangerouslySetInnerHTML={{ __html: escapeHtml(mnemonic) }}
-              />
+              <span>{mnemonic}</span>
             </div>
           )}
         </div>
diff --git a/frontend/src/components/Sidebar.tsx b/frontend/src/components/Sidebar.tsx
index 6f30a3c..cae0f70 100644
--- a/frontend/src/components/Sidebar.tsx
+++ b/frontend/src/components/Sidebar.tsx
@@ -9,14 +9,14 @@ export function Sidebar() {
     deleteConversation,
     renameConversation,
     toggleSidebar,
-    changeLanguage,
+    changeUiLanguage,
   } = useApp();
   const {
     conversations,
     currentConversationId,
     sidebarOpen,
     availableLanguages,
-    currentLanguage,
+    uiLanguage,
   } = state;
 
   // Helper to get flag for a language code
@@ -31,8 +31,9 @@ export function Sidebar() {
   const inputRef = useRef<HTMLInputElement>(null);
   const langMenuRef = useRef<HTMLDivElement>(null);
 
+  // Use uiLanguage for the button display (doesn't change when switching conversations)
   const currentLang = availableLanguages.find(
-    (l) => l.code === currentLanguage
+    (l) => l.code === uiLanguage
   );
 
   // Focus input when editing starts
@@ -58,8 +59,8 @@ export function Sidebar() {
   }, []);
 
   const handleLanguageSelect = (langCode: string) => {
-    if (langCode !== currentLanguage) {
-      changeLanguage(langCode);
+    if (langCode !== uiLanguage) {
+      changeUiLanguage(langCode);
     }
     setShowLangMenu(false);
   };
@@ -144,7 +145,7 @@ export function Sidebar() {
                 {availableLanguages.map((lang) => (
                   <button
                     key={lang.code}
-                    className={`lang-option ${lang.code === currentLanguage ? 'active' : ''}`}
+                    className={`lang-option ${lang.code === uiLanguage ? 'active' : ''}`}
                     onClick={() => handleLanguageSelect(lang.code)}
                   >
                     <span className="lang-flag">{lang.flag}</span>
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 74e1c1a..865dd7c 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -46,6 +46,7 @@ const getApiUrl = (path: string): string => {
 type AppAction =
   | { type: 'SET_CONNECTION_STATUS'; payload: ConnectionStatus }
   | { type: 'SET_LANGUAGE'; payload: string }
+  | { type: 'SET_UI_LANGUAGE'; payload: string }
   | { type: 'SET_AVAILABLE_LANGUAGES'; payload: Language[] }
   | { type: 'SET_CHAT_HISTORY'; payload: ChatMessage[] }
   | { type: 'ADD_MESSAGE'; payload: ChatMessage }
@@ -72,12 +73,14 @@ type AppAction =
   | { type: 'ADD_CONVERSATION'; payload: ConversationSummary }
   | { type: 'REMOVE_CONVERSATION'; payload: string }
   | { type: 'RENAME_CONVERSATION'; payload: { id: string; title: string } }
-  | { type: 'SET_USER_ID'; payload: string | null };
+  | { type: 'SET_USER_ID'; payload: string | null }
+  | { type: 'SET_SWITCHING_CONVERSATION'; payload: boolean };
 
 // Initial state
 const createInitialState = (storage: HybridStorage): AppState => ({
   connectionStatus: 'connecting',
   currentLanguage: storage.getLanguage(),
+  uiLanguage: storage.getUiLanguage() || 'es',
   availableLanguages: [],
   chatHistory: [],
   currentTranscript: '',
@@ -94,6 +97,7 @@ const createInitialState = (storage: HybridStorage): AppState => ({
   conversations: [],
   currentConversationId: null,
   sidebarOpen: false,
+  switchingConversation: false,
 });
 
 // Reducer
@@ -103,6 +107,8 @@ function appReducer(state: AppState, action: AppAction): AppState {
       return { ...state, connectionStatus: action.payload };
     case 'SET_LANGUAGE':
       return { ...state, currentLanguage: action.payload };
+    case 'SET_UI_LANGUAGE':
+      return { ...state, uiLanguage: action.payload };
     case 'SET_AVAILABLE_LANGUAGES':
       return { ...state, availableLanguages: action.payload };
     case 'SET_CHAT_HISTORY':
@@ -203,6 +209,8 @@ function appReducer(state: AppState, action: AppAction): AppState {
       };
     case 'SET_USER_ID':
       return { ...state, userId: action.payload };
+    case 'SET_SWITCHING_CONVERSATION':
+      return { ...state, switchingConversation: action.payload };
     default:
       return state;
   }
@@ -218,7 +226,7 @@ interface AppContextType {
   audioPlayer: AudioPlayer;
   // Actions
   toggleRecording: () => Promise<void>;
-  changeLanguage: (newLanguage: string) => void;
+  changeUiLanguage: (newLanguage: string) => void;
   handleInterrupt: () => void;
   sendTextMessage: (text: string) => void;
   pronounceWord: (text: string) => void;
@@ -658,11 +666,6 @@ export function AppProvider({ children }: AppProviderProps) {
       });
 
       if (status === 'connected') {
-        wsClient.send({
-          type: 'set_language',
-          languageCode: stateRef.current.currentLanguage,
-        });
-
         const existingConversation = storage.getConversationHistory();
         if (existingConversation.messages.length > 0) {
           wsClient.send({
@@ -673,23 +676,33 @@ export function AppProvider({ children }: AppProviderProps) {
       }
     });
 
-    wsClient.on('transcript_update', (text) => {
-      dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: text as string });
-      dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
-    });
-
     wsClient.on('speech_detected', (data) => {
-      dispatch({
-        type: 'SET_CURRENT_TRANSCRIPT',
-        payload: (data as { text?: string })?.text || '',
-      });
-      dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
-      handleInterruptRef.current();
+      const payload = data as { text?: string; conversationId?: string };
+      
+      // Only process if it's for the current conversation
+      if (
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
+      ) {
+        dispatch({
+          type: 'SET_CURRENT_TRANSCRIPT',
+          payload: payload.text || '',
+        });
+        dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
+        handleInterruptRef.current();
+      }
     });
 
     wsClient.on('partial_transcript', (data) => {
-      const text = (data as { text?: string })?.text;
-      if (text) {
+      const payload = data as { text?: string; conversationId?: string };
+      const text = payload.text;
+      
+      // Only process if it's for the current conversation
+      if (
+        text &&
+        (!payload.conversationId ||
+          payload.conversationId === stateRef.current.currentConversationId)
+      ) {
         dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: text });
         dispatch({ type: 'SET_SPEECH_DETECTED', payload: true });
       }
@@ -703,17 +716,48 @@ export function AppProvider({ children }: AppProviderProps) {
     });
 
     wsClient.on('transcription', (data) => {
-      const text = (data as { text: string }).text;
-      audioPlayer.stop();
+      const payload = data as { text: string; conversationId?: string };
+      const text = payload.text;
+      
+      // Only process if it's for the current conversation
+      if (
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
+      ) {
+        audioPlayer.stop();
 
-      dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
-      dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+        dispatch({ type: 'SET_CURRENT_TRANSCRIPT', payload: '' });
+        dispatch({ type: 'SET_SPEECH_DETECTED', payload: false });
+
+        // If the last message was sent via text input, ignore this transcription event
+        // because the user message was already added in sendTextMessage
+        if (lastMessageWasTextRef.current) {
+          lastMessageWasTextRef.current = false;
+          // Still need to check for LLM response and update conversation
+          if (
+            pendingLLMResponseRef.current &&
+            !stateRef.current.streamingLLMResponse
+          ) {
+            checkAndUpdateConversationRef.current();
+          }
+
+          if (
+            stateRef.current.streamingLLMResponse?.trim() &&
+            stateRef.current.llmResponseComplete &&
+            !pendingLLMResponseRef.current
+          ) {
+            pendingLLMResponseRef.current = stateRef.current.streamingLLMResponse;
+            checkAndUpdateConversationRef.current();
+          }
+
+          dispatch({ type: 'RESET_STREAMING_STATE' });
+          checkAndUpdateConversationRef.current();
+          return;
+        }
+
+        // This is an audio-based transcription - set pending transcription
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
 
-      // If the last message was sent via text input, ignore this transcription event
-      // because the user message was already added in sendTextMessage
-      if (lastMessageWasTextRef.current) {
-        lastMessageWasTextRef.current = false;
-        // Still need to check for LLM response and update conversation
         if (
           pendingLLMResponseRef.current &&
           !stateRef.current.streamingLLMResponse
@@ -732,73 +776,95 @@ export function AppProvider({ children }: AppProviderProps) {
 
         dispatch({ type: 'RESET_STREAMING_STATE' });
         checkAndUpdateConversationRef.current();
-        return;
       }
+    });
 
-      // This is an audio-based transcription - set pending transcription
-      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: text });
-
+    wsClient.on('llm_response_chunk', (data) => {
+      const payload = data as { text: string; conversationId?: string };
+      
+      // Only process if it's for the current conversation
       if (
-        pendingLLMResponseRef.current &&
-        !stateRef.current.streamingLLMResponse
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
       ) {
-        checkAndUpdateConversationRef.current();
+        if (!stateRef.current.llmResponseComplete) {
+          dispatch({
+            type: 'APPEND_LLM_CHUNK',
+            payload: payload.text,
+          });
+        }
       }
+    });
 
+    wsClient.on('llm_response_complete', (data) => {
+      const payload = data as { text?: string; conversationId?: string };
+      
+      // Only process if it's for the current conversation
       if (
-        stateRef.current.streamingLLMResponse?.trim() &&
-        stateRef.current.llmResponseComplete &&
-        !pendingLLMResponseRef.current
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
       ) {
-        pendingLLMResponseRef.current = stateRef.current.streamingLLMResponse;
-        checkAndUpdateConversationRef.current();
-      }
+        const responseId = `response_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        dispatch({ type: 'SET_RESPONSE_ID', payload: responseId });
+        dispatch({ type: 'SET_LLM_COMPLETE', payload: true });
 
-      dispatch({ type: 'RESET_STREAMING_STATE' });
-      checkAndUpdateConversationRef.current();
-    });
+        const finalText =
+          payload.text || stateRef.current.streamingLLMResponse;
+        dispatch({ type: 'SET_STREAMING_LLM_RESPONSE', payload: finalText });
 
-    wsClient.on('llm_response_chunk', (data) => {
-      if (!stateRef.current.llmResponseComplete) {
-        dispatch({
-          type: 'APPEND_LLM_CHUNK',
-          payload: (data as { text: string }).text,
-        });
+        // Store the LLM response and trigger conversation update
+        pendingLLMResponseRef.current = finalText;
+        checkAndUpdateConversationRef.current();
       }
     });
 
-    wsClient.on('llm_response_complete', (data) => {
-      const responseId = `response_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-      dispatch({ type: 'SET_RESPONSE_ID', payload: responseId });
-      dispatch({ type: 'SET_LLM_COMPLETE', payload: true });
-
-      const finalText =
-        (data as { text?: string }).text ||
-        stateRef.current.streamingLLMResponse;
-      dispatch({ type: 'SET_STREAMING_LLM_RESPONSE', payload: finalText });
-
-      // Store the LLM response and trigger conversation update
-      pendingLLMResponseRef.current = finalText;
-      checkAndUpdateConversationRef.current();
-    });
-
     wsClient.on('audio_stream', (data) => {
-      const audioData = data as AudioStreamData;
-      audioPlayer.addAudioStream(
-        audioData.audio,
-        audioData.sampleRate,
-        false,
-        audioData.audioFormat
-      );
+      const audioData = data as AudioStreamData & { conversationId?: string };
+      
+      // Block all audio during conversation switch
+      if (stateRef.current.switchingConversation) {
+        return;
+      }
+      
+      // Only process if it's for the current conversation
+      if (
+        !audioData.conversationId ||
+        audioData.conversationId === stateRef.current.currentConversationId
+      ) {
+        audioPlayer.addAudioStream(
+          audioData.audio,
+          audioData.sampleRate,
+          false,
+          audioData.audioFormat
+        );
+      }
     });
 
-    wsClient.on('audio_stream_complete', () => {
-      audioPlayer.markStreamComplete();
+    wsClient.on('audio_stream_complete', (data) => {
+      // Block all audio during conversation switch
+      if (stateRef.current.switchingConversation) {
+        return;
+      }
+      
+      const payload = data as { conversationId?: string };
+      
+      // Only process if it's for the current conversation
+      if (
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
+      ) {
+        audioPlayer.markStreamComplete();
+      }
     });
 
     // TTS pronunciation handlers (for flashcard pronunciation)
     const ttsAudioPlayer = ttsAudioPlayerRef.current;
     wsClient.on('tts_pronounce_audio', (data) => {
+      // Block all audio during conversation switch
+      if (stateRef.current.switchingConversation) {
+        return;
+      }
+      
       const audioData = data as {
         audio: string;
         audioFormat: string;
@@ -813,37 +879,60 @@ export function AppProvider({ children }: AppProviderProps) {
     });
 
     wsClient.on('tts_pronounce_complete', () => {
+      // Block all audio during conversation switch
+      if (stateRef.current.switchingConversation) {
+        return;
+      }
       dispatch({ type: 'SET_PRONOUNCING_CARD_ID', payload: null });
     });
 
     wsClient.on('tts_pronounce_error', () => {
+      // Block all audio during conversation switch
+      if (stateRef.current.switchingConversation) {
+        return;
+      }
       dispatch({ type: 'SET_PRONOUNCING_CARD_ID', payload: null });
     });
 
     wsClient.on('interrupt', (data) => {
-      const reason = (data as { reason?: string })?.reason;
-
-      if (reason === 'continuation_detected') {
-        // User is continuing their utterance - discard partial response silently
-        console.log(
-          '[AppContext] Continuation detected - discarding partial response'
-        );
-        audioPlayer.stop();
-        // Don't save the partial response - just reset streaming state
-        dispatch({ type: 'RESET_STREAMING_STATE' });
-        pendingLLMResponseRef.current = null;
-      } else {
-        // Normal interrupt (speech_start) - use regular interrupt handling
-        handleInterruptRef.current();
+      const payload = data as { reason?: string; conversationId?: string };
+      const reason = payload.reason;
+      
+      // Only process if it's for the current conversation
+      if (
+        !payload.conversationId ||
+        payload.conversationId === stateRef.current.currentConversationId
+      ) {
+        if (reason === 'continuation_detected') {
+          // User is continuing their utterance - discard partial response silently
+          console.log(
+            '[AppContext] Continuation detected - discarding partial response'
+          );
+          audioPlayer.stop();
+          // Don't save the partial response - just reset streaming state
+          dispatch({ type: 'RESET_STREAMING_STATE' });
+          pendingLLMResponseRef.current = null;
+        } else {
+          // Normal interrupt (speech_start) - use regular interrupt handling
+          handleInterruptRef.current();
+        }
       }
     });
 
     wsClient.on('conversation_rollback', (data) => {
       // Server removed messages due to utterance continuation - sync frontend state
-      const { messages, removedCount } = data as {
+      const payload = data as {
         messages: Array<{ role: string; content: string }>;
         removedCount: number;
+        conversationId?: string;
       };
+      const { messages, removedCount, conversationId } = payload;
+      
+      // Only process if it's for the current conversation
+      if (
+        !conversationId ||
+        conversationId === stateRef.current.currentConversationId
+      ) {
       console.log(
         `[AppContext] Conversation rollback - removed ${removedCount} messages`
       );
@@ -863,43 +952,108 @@ export function AppProvider({ children }: AppProviderProps) {
         storage.addMessage(m.role === 'user' ? 'user' : 'assistant', m.content);
       });
 
-      // Clear any pending state
-      dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
-      pendingLLMResponseRef.current = null;
+        // Clear any pending state
+        dispatch({ type: 'SET_PENDING_TRANSCRIPTION', payload: null });
+        pendingLLMResponseRef.current = null;
+      }
     });
 
-    wsClient.on('flashcards_generated', (flashcards) => {
-      const cards = flashcards as Flashcard[];
-      const currentConvoId = stateRef.current.currentConversationId;
-      if (currentConvoId) {
+    wsClient.on('flashcards_generated', (data) => {
+      const payload = data as { flashcards: Flashcard[]; conversationId?: string };
+      const cards = payload.flashcards || (data as Flashcard[]);
+      const conversationId = payload.conversationId;
+      
+      // Use conversationId from payload if provided, otherwise use current
+      const targetConversationId = conversationId || stateRef.current.currentConversationId;
+      
+      if (targetConversationId) {
         // Conversation exists - store flashcards immediately
         const updatedFlashcards = storage.addFlashcardsForConversation(
-          currentConvoId,
-          cards,
+          targetConversationId,
+          Array.isArray(cards) ? cards : [],
           stateRef.current.currentLanguage
         );
-        dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+        
+        // Only update UI if this is for the current conversation
+        if (targetConversationId === stateRef.current.currentConversationId) {
+          dispatch({ type: 'SET_FLASHCARDS', payload: updatedFlashcards });
+        }
       } else {
         // No conversation yet - queue flashcards for later processing
         console.log(
-          `[AppContext] Queuing ${cards.length} flashcards (no conversation yet)`
+          `[AppContext] Queuing ${Array.isArray(cards) ? cards.length : 0} flashcards (no conversation yet)`
         );
         pendingFlashcardsRef.current = [
           ...pendingFlashcardsRef.current,
-          ...cards,
+          ...(Array.isArray(cards) ? cards : []),
         ];
       }
     });
 
     wsClient.on('feedback_generated', (data) => {
-      const { messageContent, feedback } = data as FeedbackGeneratedPayload;
-      dispatch({ type: 'SET_FEEDBACK', payload: { messageContent, feedback } });
+      const payload = data as FeedbackGeneratedPayload & { conversationId?: string };
+      const { messageContent, feedback, conversationId } = payload;
+      
+      // Only process feedback if it's for the current conversation
+      if (!conversationId || conversationId === stateRef.current.currentConversationId) {
+        dispatch({ type: 'SET_FEEDBACK', payload: { messageContent, feedback } });
+      }
     });
 
-    wsClient.on('language_changed', (data) => {
-      console.log(
-        `Language changed to ${(data as { languageName: string }).languageName}`
-      );
+    wsClient.on('conversation_ready', (data) => {
+      const { conversationId, languageCode } = data as {
+        conversationId: string;
+        languageCode: string;
+      };
+      
+      // Ensure all audio is stopped
+      const audioHandler = audioHandlerRef.current;
+      const audioPlayer = audioPlayerRef.current;
+      const ttsAudioPlayer = ttsAudioPlayerRef.current;
+      audioHandler.stopStreaming();
+      audioPlayer.stop();
+      ttsAudioPlayer.stop();
+      
+      const storage = storageRef.current;
+      
+      // Update language if needed
+      if (languageCode && languageCode !== stateRef.current.currentLanguage) {
+        dispatch({ type: 'SET_LANGUAGE', payload: languageCode });
+        storage.saveLanguage(languageCode);
+      }
+
+      // Load the conversation data
+      const conversationData = storage.getConversation(conversationId);
+      if (conversationData) {
+        const chatHistory = conversationData.messages.map((m) => ({
+          role: m.role === 'user' ? 'learner' : 'teacher',
+          content: m.content,
+        })) as ChatMessage[];
+        dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+      } else {
+        dispatch({ type: 'SET_CHAT_HISTORY', payload: [] });
+      }
+
+      dispatch({
+        type: 'SET_CURRENT_CONVERSATION_ID',
+        payload: conversationId,
+      });
+      storage.setCurrentConversationId(languageCode, conversationId);
+
+      // Load flashcards for this specific conversation
+      const flashcards = storage.getFlashcardsForConversation(conversationId);
+      dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+
+      // Reset streaming state
+      dispatch({ type: 'RESET_STREAMING_STATE' });
+      pendingLLMResponseRef.current = null;
+      lastMessageWasTextRef.current = false;
+      pendingFlashcardsRef.current = [];
+      
+      // Hide loading screen
+      dispatch({ type: 'SET_SWITCHING_CONVERSATION', payload: false });
+      
+      console.log(`Conversation ${conversationId} ready with language ${languageCode}`);
     });
 
     // Connect
@@ -943,7 +1097,6 @@ export function AppProvider({ children }: AppProviderProps) {
           timezone: tz,
           // Use auth user ID - will be null if not authenticated
           userId: user?.id || null,
-          languageCode: state.currentLanguage,
         });
       } catch {
         // ignore
@@ -975,12 +1128,14 @@ export function AppProvider({ children }: AppProviderProps) {
     }
   }, [state.isRecording]);
 
-  // Change language (only changes the current language for new conversations)
-  const changeLanguage = useCallback((newLanguage: string) => {
+  // Change UI language preference (for the button and new conversations)
+  const changeUiLanguage = useCallback((newLanguage: string) => {
     const storage = storageRef.current;
 
-    dispatch({ type: 'SET_LANGUAGE', payload: newLanguage });
-    storage.saveLanguage(newLanguage);
+    // Only update UI language (for the button and new conversations)
+    // currentLanguage should only change when switching/creating conversations
+    dispatch({ type: 'SET_UI_LANGUAGE', payload: newLanguage });
+    storage.saveUiLanguage(newLanguage);
   }, []);
 
   // Send text message (bypasses audio/STT)
@@ -1075,7 +1230,6 @@ export function AppProvider({ children }: AppProviderProps) {
       wsClient.send({
         type: 'tts_pronounce_request',
         text: trimmedText,
-        languageCode: state.currentLanguage,
       });
     },
     [state.connectionStatus, state.currentLanguage]
@@ -1124,52 +1278,67 @@ export function AppProvider({ children }: AppProviderProps) {
       const targetLanguage =
         conversation?.languageCode || state.currentLanguage;
 
-      // Switch language if different
-      if (targetLanguage !== state.currentLanguage) {
-        dispatch({ type: 'SET_LANGUAGE', payload: targetLanguage });
-        storage.saveLanguage(targetLanguage);
-        if (state.connectionStatus === 'connected') {
-          wsClient.send({ type: 'set_language', languageCode: targetLanguage });
-        }
-      }
-
-      // Load the selected conversation
+      // Load the selected conversation data
       const conversationData = storage.getConversation(conversationId);
-      if (conversationData) {
-        const chatHistory = conversationData.messages.map((m) => ({
-          role: m.role === 'user' ? 'learner' : 'teacher',
-          content: m.content,
-        })) as ChatMessage[];
-        dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+
+      // Send conversation_switch message to backend
+      if (state.connectionStatus === 'connected') {
+        // Stop all audio immediately when switching starts - do this FIRST
+        audioHandler.stopStreaming();
+        audioPlayer.stop();
+        ttsAudioPlayer.stop();
+        
+        // Clear any pending audio streams by stopping again after a brief delay
+        // This ensures any queued audio is also stopped
+        setTimeout(() => {
+          audioPlayer.stop();
+          ttsAudioPlayer.stop();
+        }, 50);
+        
+        // Show loading screen
+        dispatch({ type: 'SET_SWITCHING_CONVERSATION', payload: true });
+        
+        // Don't update UI yet - wait for conversation_ready message
+        // Send switch request to backend
+        wsClient.send({
+          type: 'conversation_switch',
+          conversationId: conversationId,
+          languageCode: targetLanguage,
+          messages: conversationData?.messages || [],
+        });
+        
+        // UI will be updated when conversation_ready is received
       } else {
-        dispatch({ type: 'SET_CHAT_HISTORY', payload: [] });
-      }
+        // If not connected, update UI immediately
+        if (targetLanguage !== state.currentLanguage) {
+          dispatch({ type: 'SET_LANGUAGE', payload: targetLanguage });
+          storage.saveLanguage(targetLanguage);
+        }
 
-      dispatch({
-        type: 'SET_CURRENT_CONVERSATION_ID',
-        payload: conversationId,
-      });
-      storage.setCurrentConversationId(targetLanguage, conversationId);
+        if (conversationData) {
+          const chatHistory = conversationData.messages.map((m) => ({
+            role: m.role === 'user' ? 'learner' : 'teacher',
+            content: m.content,
+          })) as ChatMessage[];
+          dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+        } else {
+          dispatch({ type: 'SET_CHAT_HISTORY', payload: [] });
+        }
 
-      // Load flashcards for this specific conversation
-      const flashcards = storage.getFlashcardsForConversation(conversationId);
-      dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
+        dispatch({
+          type: 'SET_CURRENT_CONVERSATION_ID',
+          payload: conversationId,
+        });
+        storage.setCurrentConversationId(targetLanguage, conversationId);
 
-      // Reset streaming state and clear pending flashcards (they belong to old conversation)
-      dispatch({ type: 'RESET_STREAMING_STATE' });
-      pendingLLMResponseRef.current = null;
-      lastMessageWasTextRef.current = false;
-      pendingFlashcardsRef.current = [];
+        const flashcards = storage.getFlashcardsForConversation(conversationId);
+        dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
 
-      // Update the WebSocket with the loaded conversation
-      if (state.connectionStatus === 'connected') {
-        wsClient.send({ type: 'conversation_context_reset' });
-        if (conversationData && conversationData.messages.length > 0) {
-          wsClient.send({
-            type: 'conversation_update',
-            data: { messages: conversationData.messages },
-          });
-        }
+        dispatch({ type: 'RESET_STREAMING_STATE' });
+        pendingLLMResponseRef.current = null;
+        lastMessageWasTextRef.current = false;
+        pendingFlashcardsRef.current = [];
+        dispatch({ type: 'SET_SWITCHING_CONVERSATION', payload: false });
       }
 
       // Close sidebar on mobile
@@ -1218,9 +1387,9 @@ export function AppProvider({ children }: AppProviderProps) {
       );
     }
 
-    // Create new conversation with the current language preference
-    // Use state.currentLanguage directly since it's in the dependencies and will be up-to-date
-    const languageForNewConversation = state.currentLanguage;
+    // Create new conversation with the language shown on the button (uiLanguage)
+    // This ensures the new conversation uses the language the user selected/expects
+    const languageForNewConversation = state.uiLanguage;
     const newConversation = storage.createConversation(
       languageForNewConversation
     );
@@ -1241,17 +1410,29 @@ export function AppProvider({ children }: AppProviderProps) {
     lastMessageWasTextRef.current = false;
     pendingFlashcardsRef.current = [];
 
-    // Reset and set language for new conversation
-    // We need to reset first, then set language to ensure the conversation starts fresh
-    // Even if the language is the same, we want to reset the conversation state
+    // For new conversations, send conversation_switch with empty messages
     if (state.connectionStatus === 'connected') {
-      // Reset the conversation context first
-      wsClient.send({ type: 'conversation_context_reset' });
-      // Then set the language (this will also reset, but ensures language is correct)
+      // Stop all audio immediately when switching starts - do this FIRST
+      audioHandler.stopStreaming();
+      audioPlayer.stop();
+      ttsAudioPlayer.stop();
+      
+      // Clear any pending audio streams by stopping again after a brief delay
+      setTimeout(() => {
+        audioPlayer.stop();
+        ttsAudioPlayer.stop();
+      }, 50);
+      
+      dispatch({ type: 'SET_SWITCHING_CONVERSATION', payload: true });
+      
       wsClient.send({
-        type: 'set_language',
+        type: 'conversation_switch',
+        conversationId: newConversation.id,
         languageCode: languageForNewConversation,
+        messages: [],
       });
+    } else {
+      dispatch({ type: 'SET_SWITCHING_CONVERSATION', payload: false });
     }
 
     // Close sidebar on mobile
@@ -1259,7 +1440,7 @@ export function AppProvider({ children }: AppProviderProps) {
   }, [
     state.isRecording,
     state.currentConversationId,
-    state.currentLanguage,
+    state.uiLanguage,
     state.connectionStatus,
   ]);
 
@@ -1340,7 +1521,7 @@ export function AppProvider({ children }: AppProviderProps) {
       audioHandler: audioHandlerInstance,
       audioPlayer: audioPlayerInstance,
       toggleRecording,
-      changeLanguage,
+      changeUiLanguage,
       handleInterrupt,
       sendTextMessage,
       pronounceWord,
@@ -1358,7 +1539,7 @@ export function AppProvider({ children }: AppProviderProps) {
       audioHandlerInstance,
       audioPlayerInstance,
       toggleRecording,
-      changeLanguage,
+      changeUiLanguage,
       handleInterrupt,
       sendTextMessage,
       pronounceWord,
diff --git a/frontend/src/services/AudioPlayer.ts b/frontend/src/services/AudioPlayer.ts
index eef0f6f..a36a341 100644
--- a/frontend/src/services/AudioPlayer.ts
+++ b/frontend/src/services/AudioPlayer.ts
@@ -230,6 +230,12 @@ export class AudioPlayer {
   }
 
   stop(): void {
+    // Clear stream timeout
+    if (this.streamTimeout) {
+      clearTimeout(this.streamTimeout);
+      this.streamTimeout = null;
+    }
+
     // Use iOS handler if available
     if (this.isIOS && this.iosHandler) {
       this.iosHandler.stopAudioPlayback?.();
@@ -250,6 +256,7 @@ export class AudioPlayer {
       }
     }
 
+    // Clear audio queue to prevent any queued audio from playing
     this.audioQueue = [];
     this.isPlaying = false;
     this.isStartingPlayback = false;
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index 8ea6e7a..33bea18 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -15,6 +15,7 @@ export class Storage {
   private flashcardsKey = 'aprende-flashcards'; // Legacy per-language flashcards
   private flashcardsConversationKeyPrefix = 'aprende-flashcards-conv-'; // + conversationId
   private languageKey = 'aprende-language';
+  private uiLanguageKey = 'aprende-ui-language';
 
   // Language preference methods
   getLanguage(): string {
@@ -34,6 +35,23 @@ export class Storage {
     }
   }
 
+  getUiLanguage(): string {
+    try {
+      return localStorage.getItem(this.uiLanguageKey) || 'es';
+    } catch (error) {
+      console.error('Failed to load UI language from localStorage:', error);
+      return 'es';
+    }
+  }
+
+  saveUiLanguage(languageCode: string): void {
+    try {
+      localStorage.setItem(this.uiLanguageKey, languageCode);
+    } catch (error) {
+      console.error('Failed to save UI language to localStorage:', error);
+    }
+  }
+
   // State methods
   saveState(state: { chatHistory: unknown[] }): void {
     try {
diff --git a/frontend/src/services/WebSocketClient.ts b/frontend/src/services/WebSocketClient.ts
index b7d4be4..69c5869 100644
--- a/frontend/src/services/WebSocketClient.ts
+++ b/frontend/src/services/WebSocketClient.ts
@@ -198,9 +198,6 @@ export class WebSocketClient {
     [key: string]: unknown;
   }): void {
     switch (message.type) {
-      case 'transcript_update':
-        this.emit('transcript_update', (message.data as { text: string }).text);
-        break;
 
       case 'transcription':
         this.emit('transcription', {
@@ -321,6 +318,13 @@ export class WebSocketClient {
         });
         break;
 
+      case 'conversation_ready':
+        this.emit('conversation_ready', {
+          conversationId: message.conversationId,
+          languageCode: message.languageCode,
+        });
+        break;
+
       default:
         console.log('Unknown message type:', message.type);
     }
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 280697a..09463e3 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -790,7 +790,20 @@ body {
     gap: 32px;
     height: calc(100vh - 144px);
     overflow-x: hidden;
-    overflow-y: visible;
+    position: relative;
+}
+
+.conversation-switch-loading {
+    grid-column: 1 / -1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    background: #ffffff;
+    border-radius: 12px;
+    border: 1px solid #e5e5e5;
+    height: 100%;
+    min-height: 400px;
 }
 
 /* Section Headers */
@@ -918,9 +931,9 @@ body {
     padding: 16px 0;
     display: flex;
     flex-direction: column;
+    position: relative;
     gap: 16px;
     min-height: 0;
-    position: relative;
 }
 
 /* Chat loading state */
@@ -928,10 +941,13 @@ body {
     position: absolute;
     inset: 0;
     display: flex;
+    flex-direction: column;
     align-items: center;
     justify-content: center;
-    background: rgba(255, 255, 255, 0.8);
+    background: #ffffff;
     z-index: 10;
+    width: 100%;
+    height: 100%;
 }
 
 .chat-loading-spinner {
@@ -943,6 +959,13 @@ body {
     animation: spin 0.8s linear infinite;
 }
 
+.chat-loading-text {
+    margin-top: 12px;
+    font-size: 14px;
+    color: #6b7280;
+    text-align: center;
+}
+
 @keyframes spin {
     to {
         transform: rotate(360deg);
@@ -1110,6 +1133,7 @@ body {
 .flashcards-container {
     flex: 1;
     min-height: 0;
+    position: relative;
 }
 
 .flashcards-grid {
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 97bdac5..4d9b327 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -132,6 +132,7 @@ export interface AppState {
   // Language
   currentLanguage: string;
   availableLanguages: Language[];
+  uiLanguage: string; // Language displayed in the UI selector (doesn't change when switching conversations)
 
   // Chat
   chatHistory: ChatMessage[];
@@ -159,6 +160,7 @@ export interface AppState {
   conversations: ConversationSummary[];
   currentConversationId: string | null;
   sidebarOpen: boolean;
+  switchingConversation: boolean;
 }
 
 // Outgoing WebSocket message

From d491f080951c6de2433ed2034bcc2a0ec48e3d92 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 15 Jan 2026 15:34:26 -0800
Subject: [PATCH 44/49] Fixed flashcard audio playing in wrong language

---
 backend/src/graphs/simple-tts-graph.ts    | 47 ++++++++++++++++-------
 backend/src/services/graph-service.ts     |  7 +++-
 backend/src/services/websocket-handler.ts | 10 ++++-
 3 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/backend/src/graphs/simple-tts-graph.ts b/backend/src/graphs/simple-tts-graph.ts
index 299b739..cdae811 100644
--- a/backend/src/graphs/simple-tts-graph.ts
+++ b/backend/src/graphs/simple-tts-graph.ts
@@ -18,7 +18,7 @@ import {
   ProcessContext,
   RemoteTTSNode,
 } from '@inworld/runtime/graph';
-import { getLanguageConfig } from '../config/languages.js';
+import { getLanguageConfig, getSupportedLanguageCodes } from '../config/languages.js';
 import { serverConfig } from '../config/server.js';
 import { graphLogger as logger } from '../utils/logger.js';
 
@@ -39,11 +39,9 @@ class TextExtractorNode extends CustomNode {
 /**
  * Creates a simple TTS graph for pronouncing words
  * RemoteTTSNode accepts String directly as input
- * Language is hardcoded to Spanish
  */
 function createSimpleTTSGraph(languageCode: string): Graph {
-  // Language is hardcoded to Spanish, ignore parameter
-  const langConfig = getLanguageConfig('es');
+  const langConfig = getLanguageConfig(languageCode);
 
   logger.info(
     {
@@ -55,12 +53,12 @@ function createSimpleTTSGraph(languageCode: string): Graph {
   );
 
   const textExtractorNode = new TextExtractorNode({
-    id: 'simple-tts-text-extractor',
+    id: `simple-tts-text-extractor-${languageCode}`,
   });
 
   // RemoteTTSNode accepts String directly as input
   const ttsNode = new RemoteTTSNode({
-    id: 'simple-tts-node',
+    id: `simple-tts-node-${languageCode}`,
     speakerId: langConfig.ttsConfig.speakerId,
     modelId: langConfig.ttsConfig.modelId,
     sampleRate: serverConfig.audio.ttsSampleRate,
@@ -85,17 +83,38 @@ function createSimpleTTSGraph(languageCode: string): Graph {
   return graphBuilder.build();
 }
 
-// Cache for simple TTS graph (always Spanish)
-let simpleTTSGraph: Graph | null = null;
+// Cache for simple TTS graphs per language
+const simpleTTSGraphs = new Map<string, Graph>();
 
 /**
- * Get or create a simple TTS graph (always Spanish)
+ * Initialize TTS graphs for all supported languages
+ */
+export function initializeTTSGraphs(): void {
+  const languageCodes = getSupportedLanguageCodes();
+  
+  logger.info({ languageCount: languageCodes.length }, 'initializing_tts_graphs');
+  
+  for (const languageCode of languageCodes) {
+    if (!simpleTTSGraphs.has(languageCode)) {
+      logger.info({ languageCode }, 'creating_tts_graph');
+      simpleTTSGraphs.set(languageCode, createSimpleTTSGraph(languageCode));
+    }
+  }
+  
+  logger.info(
+    { graphCount: simpleTTSGraphs.size },
+    'tts_graphs_initialized'
+  );
+}
+
+/**
+ * Get TTS graph for a specific language
  */
 export function getSimpleTTSGraph(languageCode: string): Graph {
-  // Language is hardcoded to Spanish, ignore parameter
-  if (!simpleTTSGraph) {
-    logger.info({ languageCode: 'es' }, 'creating_simple_tts_graph');
-    simpleTTSGraph = createSimpleTTSGraph('es');
+  // If graph doesn't exist, create it (fallback for new languages)
+  if (!simpleTTSGraphs.has(languageCode)) {
+    logger.info({ languageCode }, 'creating_tts_graph_on_demand');
+    simpleTTSGraphs.set(languageCode, createSimpleTTSGraph(languageCode));
   }
-  return simpleTTSGraph;
+  return simpleTTSGraphs.get(languageCode)!;
 }
diff --git a/backend/src/services/graph-service.ts b/backend/src/services/graph-service.ts
index 032e393..1bfd910 100644
--- a/backend/src/services/graph-service.ts
+++ b/backend/src/services/graph-service.ts
@@ -16,7 +16,7 @@ import {
 } from '../graphs/conversation-graph.js';
 import { getFlashcardGraph } from '../graphs/flashcard-graph.js';
 import { getResponseFeedbackGraph } from '../graphs/response-feedback-graph.js';
-// Language is hardcoded to Spanish
+import { initializeTTSGraphs } from '../graphs/simple-tts-graph.js';
 import { serverLogger as logger } from '../utils/logger.js';
 import { connections } from './state.js';
 
@@ -43,6 +43,11 @@ export async function initializeGraph(): Promise<void> {
     defaultLanguageCode: 'es', // Always Spanish
   });
   logger.info('conversation_graph_initialized');
+
+  // Initialize TTS graphs for all supported languages
+  logger.info('initializing_tts_graphs');
+  initializeTTSGraphs();
+  logger.info('tts_graphs_initialized');
 }
 
 export async function exportGraphConfigs(): Promise<void> {
diff --git a/backend/src/services/websocket-handler.ts b/backend/src/services/websocket-handler.ts
index 1da75e8..e476809 100644
--- a/backend/src/services/websocket-handler.ts
+++ b/backend/src/services/websocket-handler.ts
@@ -578,7 +578,6 @@ async function handleTTSPronounce(
   message: { text?: string; languageCode?: string }
 ): Promise<void> {
   const text = message.text;
-  const languageCode = 'es'; // Always Spanish
 
   if (typeof text !== 'string' || text.trim().length === 0) {
     ws.send(
@@ -599,6 +598,15 @@ async function handleTTSPronounce(
   }
 
   try {
+    // Get language from connection manager (current conversation language)
+    const connectionManager = connectionManagers.get(connectionId);
+    const languageCode = connectionManager?.getLanguageCode() || message.languageCode || DEFAULT_LANGUAGE_CODE;
+    
+    logger.debug(
+      { connectionId, languageCode, textLength: text.length },
+      'tts_pronounce_starting'
+    );
+
     const graph = getSimpleTTSGraph(languageCode);
     const executionResult = await graph.start({ text: text.trim() });
 

From 3addcc3ebecb3fbe33f17c6c88a4bb1f9143672f Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 15 Jan 2026 16:20:55 -0800
Subject: [PATCH 45/49] Updated sign in and connection UI

---
 frontend/src/components/Header.tsx            | 160 ++++++++++------
 frontend/src/context/AuthContext.tsx          |  38 +++-
 frontend/src/styles/main.css                  | 178 ++++++++++++++++++
 ....sql => 20240108000000_initial_schema.sql} |   0
 4 files changed, 305 insertions(+), 71 deletions(-)
 rename supabase/migrations/{00000000000000_initial_schema.sql => 20240108000000_initial_schema.sql} (100%)

diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index e48c1c8..4fa5bef 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -15,6 +15,8 @@ export function Header() {
   const [error, setError] = useState<string | null>(null);
   const [submitting, setSubmitting] = useState(false);
   const menuRef = useRef<HTMLDivElement>(null);
+  const authFormRef = useRef<HTMLDivElement>(null);
+  const signInButtonRef = useRef<HTMLButtonElement>(null);
 
   const statusMessages: Record<string, string> = {
     connecting: 'Connecting...',
@@ -25,14 +27,33 @@ export function Header() {
   // Close menus when clicking outside
   useEffect(() => {
     function handleClickOutside(event: MouseEvent) {
-      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+      const target = event.target as Node;
+      const clickedInMenu =
+        menuRef.current && menuRef.current.contains(target);
+      const clickedInAuthForm =
+        authFormRef.current && authFormRef.current.contains(target);
+      const clickedSignInButton =
+        signInButtonRef.current && signInButtonRef.current.contains(target);
+
+      // Close menu if clicked outside
+      if (showMenu && !clickedInMenu) {
         setShowMenu(false);
+      }
+      // Close auth form if clicked outside (but not on the Sign In button itself)
+      if (showAuthForm && !clickedInAuthForm && !clickedSignInButton) {
         setShowAuthForm(false);
       }
     }
-    document.addEventListener('mousedown', handleClickOutside);
-    return () => document.removeEventListener('mousedown', handleClickOutside);
-  }, []);
+    // Use a small delay to prevent immediate closing when opening
+    const timeoutId = setTimeout(() => {
+      document.addEventListener('mousedown', handleClickOutside);
+    }, 100);
+
+    return () => {
+      clearTimeout(timeoutId);
+      document.removeEventListener('mousedown', handleClickOutside);
+    };
+  }, [showMenu, showAuthForm]);
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
@@ -92,62 +113,60 @@ export function Header() {
         </div>
 
         <div className="header-right">
-          {/* Settings Menu */}
-          <div ref={menuRef} style={{ position: 'relative' }}>
-            <button
-              className="logo-menu-button"
-              onClick={() => setShowMenu(!showMenu)}
-              aria-label="Open menu"
-            >
-              <img src="/favicon.svg" alt="Menu" className="logo-icon" />
-            </button>
+          {/* Connection Status - Always Visible */}
+          <div className="header-connection-status">
+            <span className={`status-dot ${connectionStatus}`} />
+            <span className="connection-status-text">
+              {statusMessages[connectionStatus] || 'Unknown'}
+            </span>
+          </div>
 
-            {showMenu && (
-              <div className="header-dropdown">
-                {/* Connection Status */}
-                <div className="dropdown-item dropdown-status">
-                  <span className={`status-dot ${connectionStatus}`} />
-                  <span>{statusMessages[connectionStatus] || 'Unknown'}</span>
+          {/* Auth Section - Always Visible */}
+          {isConfigured && (
+            <div className="header-auth-section">
+              {isLoading ? (
+                <div className="header-auth-loading">Loading...</div>
+              ) : user ? (
+                <div className="header-auth-user">
+                  <span className="header-auth-email" title={user.email}>
+                    {user.email}
+                  </span>
+                  <button
+                    className="header-sign-out-button"
+                    onClick={handleSignOut}
+                    title="Sign Out"
+                  >
+                    Sign Out
+                  </button>
                 </div>
-
-                {/* Auth Section */}
-                {isConfigured && (
-                  <>
-                    <div className="dropdown-divider" />
-                    {isLoading ? (
-                      <div className="dropdown-item dropdown-loading">
-                        Loading...
-                      </div>
-                    ) : user ? (
-                      <>
-                        <div className="dropdown-item dropdown-user">
-                          <span className="dropdown-label">Signed in as</span>
-                          <span className="dropdown-email">{user.email}</span>
-                        </div>
-                        <button
-                          className="dropdown-item dropdown-button"
-                          onClick={handleSignOut}
-                        >
-                          Sign Out
-                        </button>
-                      </>
-                    ) : !showAuthForm ? (
-                      <button
-                        className="dropdown-item dropdown-button"
-                        onClick={() => setShowAuthForm(true)}
-                      >
-                        Sign In
-                      </button>
-                    ) : (
-                      <form
-                        onSubmit={handleSubmit}
-                        className="dropdown-auth-form"
-                      >
-                        <div className="dropdown-auth-header">
+              ) : (
+                <>
+                  <button
+                    ref={signInButtonRef}
+                    className="header-sign-in-button"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      setShowAuthForm(!showAuthForm);
+                    }}
+                  >
+                    Sign In
+                  </button>
+                  {showAuthForm && (
+                    <div ref={authFormRef} className="header-auth-form-wrapper">
+                      <form onSubmit={handleSubmit} className="header-auth-form">
+                        <div className="header-auth-form-header">
                           {isSignUp ? 'Create Account' : 'Sign In'}
+                          <button
+                            type="button"
+                            className="header-auth-form-close"
+                            onClick={() => setShowAuthForm(false)}
+                            aria-label="Close"
+                          >
+                            ×
+                          </button>
                         </div>
                         {error && (
-                          <div className="dropdown-auth-error">{error}</div>
+                          <div className="header-auth-error">{error}</div>
                         )}
                         <input
                           type="email"
@@ -156,7 +175,7 @@ export function Header() {
                           onChange={(e) => setEmail(e.target.value)}
                           required
                           autoComplete="email"
-                          className="dropdown-input"
+                          className="header-auth-input"
                         />
                         <input
                           type="password"
@@ -168,11 +187,11 @@ export function Header() {
                           autoComplete={
                             isSignUp ? 'new-password' : 'current-password'
                           }
-                          className="dropdown-input"
+                          className="header-auth-input"
                         />
                         <button
                           type="submit"
-                          className="dropdown-submit"
+                          className="header-auth-submit"
                           disabled={submitting}
                         >
                           {submitting
@@ -183,7 +202,7 @@ export function Header() {
                         </button>
                         <button
                           type="button"
-                          className="dropdown-toggle-auth"
+                          className="header-auth-toggle"
                           onClick={toggleAuthMode}
                         >
                           {isSignUp
@@ -191,9 +210,26 @@ export function Header() {
                             : 'Need an account? Sign Up'}
                         </button>
                       </form>
-                    )}
-                  </>
-                )}
+                    </div>
+                  )}
+                </>
+              )}
+            </div>
+          )}
+
+          {/* Settings Menu */}
+          <div ref={menuRef} style={{ position: 'relative' }}>
+            <button
+              className="logo-menu-button"
+              onClick={() => setShowMenu(!showMenu)}
+              aria-label="Open menu"
+            >
+              <img src="/favicon.svg" alt="Menu" className="logo-icon" />
+            </button>
+
+            {showMenu && (
+              <div className="header-dropdown">
+                {/* Dropdown content can go here if needed */}
               </div>
             )}
           </div>
diff --git a/frontend/src/context/AuthContext.tsx b/frontend/src/context/AuthContext.tsx
index 1d61dfe..8334a93 100644
--- a/frontend/src/context/AuthContext.tsx
+++ b/frontend/src/context/AuthContext.tsx
@@ -3,6 +3,7 @@ import {
   useContext,
   useEffect,
   useState,
+  useMemo,
   type ReactNode,
 } from 'react';
 import { createClient } from '@supabase/supabase-js';
@@ -27,19 +28,38 @@ interface AuthContextType {
 
 const AuthContext = createContext<AuthContextType | null>(null);
 
-export function AuthProvider({ children }: { children: ReactNode }) {
-  const [supabase] = useState<SupabaseClient | null>(() => {
-    const url = import.meta.env.VITE_SUPABASE_URL;
-    const publishableKey = import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY;
+// Singleton Supabase client to prevent multiple instances
+let supabaseClientInstance: SupabaseClient | null = null;
 
-    if (!url || !publishableKey) {
-      console.log('Supabase not configured - running in anonymous mode');
-      return null;
-    }
+function getSupabaseClient(): SupabaseClient | null {
+  if (supabaseClientInstance) {
+    return supabaseClientInstance;
+  }
+
+  const url = import.meta.env.VITE_SUPABASE_URL;
+  const publishableKey = import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY;
+
+  if (!url || !publishableKey) {
+    console.log('Supabase not configured - running in anonymous mode');
+    return null;
+  }
 
-    return createClient(url, publishableKey);
+  supabaseClientInstance = createClient(url, publishableKey, {
+    auth: {
+      storageKey: 'aprende-auth-token',
+      autoRefreshToken: true,
+      persistSession: true,
+      detectSessionInUrl: true,
+    },
   });
 
+  return supabaseClientInstance;
+}
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  // Use useMemo to ensure client is only created once
+  const supabase = useMemo(() => getSupabaseClient(), []);
+
   const [user, setUser] = useState<User | null>(null);
   const [session, setSession] = useState<Session | null>(null);
   const isConfigured = supabase !== null;
diff --git a/frontend/src/styles/main.css b/frontend/src/styles/main.css
index 09463e3..ed19f15 100644
--- a/frontend/src/styles/main.css
+++ b/frontend/src/styles/main.css
@@ -443,6 +443,184 @@ body {
     height: 28px;
 }
 
+/* Connection Status in Header */
+.header-connection-status {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 12px;
+    border-radius: 8px;
+    background: #f9fafb;
+    font-size: 13px;
+    color: #1a1a1a;
+}
+
+.connection-status-text {
+    font-weight: 500;
+}
+
+/* Auth Section in Header */
+.header-auth-section {
+    position: relative;
+}
+
+.header-auth-loading {
+    padding: 6px 12px;
+    font-size: 13px;
+    color: #6b7280;
+}
+
+.header-auth-user {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.header-auth-email {
+    padding: 6px 12px;
+    font-size: 13px;
+    color: #1a1a1a;
+    max-width: 200px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    background: #f9fafb;
+    border-radius: 8px;
+}
+
+.header-sign-in-button,
+.header-sign-out-button {
+    padding: 6px 12px;
+    font-size: 13px;
+    font-weight: 500;
+    color: #1a1a1a;
+    background: #f9fafb;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    font-family: inherit;
+}
+
+.header-sign-in-button:hover,
+.header-sign-out-button:hover {
+    background: #f3f4f6;
+    border-color: #d1d5db;
+}
+
+.header-auth-form-wrapper {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    z-index: 100;
+}
+
+.header-auth-form {
+    background: #ffffff;
+    border: 1px solid #e5e5e5;
+    border-radius: 12px;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+    padding: 16px;
+    min-width: 280px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.header-auth-form-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 16px;
+    font-weight: 600;
+    color: #1a1a1a;
+    margin-bottom: 4px;
+}
+
+.header-auth-form-close {
+    background: none;
+    border: none;
+    font-size: 24px;
+    line-height: 1;
+    color: #6b7280;
+    cursor: pointer;
+    padding: 0;
+    width: 24px;
+    height: 24px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+    transition: background-color 0.2s ease;
+}
+
+.header-auth-form-close:hover {
+    background: #f3f4f6;
+    color: #1a1a1a;
+}
+
+.header-auth-error {
+    padding: 8px 12px;
+    background: #fee2e2;
+    color: #dc2626;
+    border-radius: 6px;
+    font-size: 13px;
+}
+
+.header-auth-input {
+    padding: 10px 12px;
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    font-size: 14px;
+    font-family: inherit;
+    color: #1a1a1a;
+    background: #ffffff;
+    transition: border-color 0.2s ease;
+}
+
+.header-auth-input:focus {
+    outline: none;
+    border-color: #1a1a1a;
+}
+
+.header-auth-submit {
+    padding: 10px 16px;
+    background: #1a1a1a;
+    color: #ffffff;
+    border: none;
+    border-radius: 8px;
+    font-size: 14px;
+    font-weight: 500;
+    font-family: inherit;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+}
+
+.header-auth-submit:hover:not(:disabled) {
+    background: #000000;
+}
+
+.header-auth-submit:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.header-auth-toggle {
+    background: none;
+    border: none;
+    color: #6b7280;
+    font-size: 13px;
+    font-family: inherit;
+    cursor: pointer;
+    padding: 4px;
+    text-align: center;
+    transition: color 0.2s ease;
+}
+
+.header-auth-toggle:hover {
+    color: #1a1a1a;
+}
+
 /* Header Dropdown */
 .header-dropdown {
     position: absolute;
diff --git a/supabase/migrations/00000000000000_initial_schema.sql b/supabase/migrations/20240108000000_initial_schema.sql
similarity index 100%
rename from supabase/migrations/00000000000000_initial_schema.sql
rename to supabase/migrations/20240108000000_initial_schema.sql

From ff99c5a26889bca1552aadbc0434eba4f21f5c6d Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 15 Jan 2026 16:36:09 -0800
Subject: [PATCH 46/49] Removed button functionality from logo

---
 frontend/src/components/Header.tsx | 31 +++++-------------------------
 1 file changed, 5 insertions(+), 26 deletions(-)

diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index 4fa5bef..f9e7970 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -7,14 +7,12 @@ export function Header() {
   const { connectionStatus } = state;
   const { user, isLoading, isConfigured, signUp, signIn, signOut } = useAuth();
 
-  const [showMenu, setShowMenu] = useState(false);
   const [showAuthForm, setShowAuthForm] = useState(false);
   const [isSignUp, setIsSignUp] = useState(false);
   const [email, setEmail] = useState('');
   const [password, setPassword] = useState('');
   const [error, setError] = useState<string | null>(null);
   const [submitting, setSubmitting] = useState(false);
-  const menuRef = useRef<HTMLDivElement>(null);
   const authFormRef = useRef<HTMLDivElement>(null);
   const signInButtonRef = useRef<HTMLButtonElement>(null);
 
@@ -24,21 +22,15 @@ export function Header() {
     disconnected: 'Disconnected',
   };
 
-  // Close menus when clicking outside
+  // Close auth form when clicking outside
   useEffect(() => {
     function handleClickOutside(event: MouseEvent) {
       const target = event.target as Node;
-      const clickedInMenu =
-        menuRef.current && menuRef.current.contains(target);
       const clickedInAuthForm =
         authFormRef.current && authFormRef.current.contains(target);
       const clickedSignInButton =
         signInButtonRef.current && signInButtonRef.current.contains(target);
 
-      // Close menu if clicked outside
-      if (showMenu && !clickedInMenu) {
-        setShowMenu(false);
-      }
       // Close auth form if clicked outside (but not on the Sign In button itself)
       if (showAuthForm && !clickedInAuthForm && !clickedSignInButton) {
         setShowAuthForm(false);
@@ -53,7 +45,7 @@ export function Header() {
       clearTimeout(timeoutId);
       document.removeEventListener('mousedown', handleClickOutside);
     };
-  }, [showMenu, showAuthForm]);
+  }, [showAuthForm]);
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
@@ -82,7 +74,6 @@ export function Header() {
 
   const handleSignOut = async () => {
     await signOut();
-    setShowMenu(false);
   };
 
   return (
@@ -217,21 +208,9 @@ export function Header() {
             </div>
           )}
 
-          {/* Settings Menu */}
-          <div ref={menuRef} style={{ position: 'relative' }}>
-            <button
-              className="logo-menu-button"
-              onClick={() => setShowMenu(!showMenu)}
-              aria-label="Open menu"
-            >
-              <img src="/favicon.svg" alt="Menu" className="logo-icon" />
-            </button>
-
-            {showMenu && (
-              <div className="header-dropdown">
-                {/* Dropdown content can go here if needed */}
-              </div>
-            )}
+          {/* Logo */}
+          <div>
+            <img src="/favicon.svg" alt="Inworld Language Tutor" className="logo-icon" />
           </div>
         </div>
       </div>

From 872ca97276d956f123e20377bcd97fa7d62b07d0 Mon Sep 17 00:00:00 2001
From: Matt Wilson <matt.wilson720@gmail.com>
Date: Thu, 15 Jan 2026 18:07:04 -0800
Subject: [PATCH 47/49] Fixed issue with language set on app refresh

---
 backend/src/services/websocket-handler.ts |  38 +++-
 frontend/src/context/AppContext.tsx       | 218 +++++++++++-----------
 frontend/src/services/Storage.ts          |  23 +--
 3 files changed, 153 insertions(+), 126 deletions(-)

diff --git a/backend/src/services/websocket-handler.ts b/backend/src/services/websocket-handler.ts
index e476809..3034a1d 100644
--- a/backend/src/services/websocket-handler.ts
+++ b/backend/src/services/websocket-handler.ts
@@ -464,23 +464,47 @@ function handleUserContext(
 ): void {
   const timezone = message.timezone || message.data?.timezone;
   const userId = message.userId || message.data?.userId;
+  const languageCode = message.languageCode || message.data?.languageCode;
   const currentAttrs = connectionAttributes.get(connectionId) || {};
 
-  // Language is hardcoded to Spanish, ignore any languageCode from client
+  // Validate language code
+  const supportedCodes = getSupportedLanguageCodes();
+  const validatedLanguageCode = languageCode && supportedCodes.includes(languageCode)
+    ? languageCode
+    : currentAttrs.languageCode || DEFAULT_LANGUAGE_CODE;
+
   connectionAttributes.set(connectionId, {
     ...currentAttrs,
     timezone: timezone || currentAttrs.timezone,
     userId: userId || currentAttrs.userId,
-    languageCode: 'es', // Always Spanish
+    languageCode: validatedLanguageCode,
   });
 
-  // Set user ID on connection manager for memory retrieval
-  if (userId) {
-    const manager = connectionManagers.get(connectionId);
-    if (manager) {
-      manager.setUserId(userId);
+  // Update connection manager and processors with the language
+  const manager = connectionManagers.get(connectionId);
+  if (manager && validatedLanguageCode !== currentAttrs.languageCode) {
+    manager.setLanguage(validatedLanguageCode);
+    
+    // Update processors with new language
+    const flashcardProcessor = flashcardProcessors.get(connectionId);
+    const feedbackProcessor = feedbackProcessors.get(connectionId);
+    const memoryProcessor = memoryProcessors.get(connectionId);
+
+    if (flashcardProcessor) {
+      flashcardProcessor.setLanguage(validatedLanguageCode);
+    }
+    if (feedbackProcessor) {
+      feedbackProcessor.setLanguage(validatedLanguageCode);
+    }
+    if (memoryProcessor) {
+      memoryProcessor.setLanguage(validatedLanguageCode);
     }
   }
+
+  // Set user ID on connection manager for memory retrieval
+  if (userId && manager) {
+    manager.setUserId(userId);
+  }
 }
 
 function handleFlashcardClicked(
diff --git a/frontend/src/context/AppContext.tsx b/frontend/src/context/AppContext.tsx
index 865dd7c..468126e 100644
--- a/frontend/src/context/AppContext.tsx
+++ b/frontend/src/context/AppContext.tsx
@@ -77,28 +77,41 @@ type AppAction =
   | { type: 'SET_SWITCHING_CONVERSATION'; payload: boolean };
 
 // Initial state
-const createInitialState = (storage: HybridStorage): AppState => ({
-  connectionStatus: 'connecting',
-  currentLanguage: storage.getLanguage(),
-  uiLanguage: storage.getUiLanguage() || 'es',
-  availableLanguages: [],
-  chatHistory: [],
-  currentTranscript: '',
-  pendingTranscription: null,
-  streamingLLMResponse: '',
-  llmResponseComplete: false,
-  currentResponseId: null,
-  isRecording: false,
-  speechDetected: false,
-  flashcards: [],
-  pronouncingCardId: null,
-  feedbackMap: {},
-  userId: null,
-  conversations: [],
-  currentConversationId: null,
-  sidebarOpen: false,
-  switchingConversation: false,
-});
+const createInitialState = (storage: HybridStorage): AppState => {
+  // Determine the language from the current conversation, not from stored preference
+  let initialLanguage = storage.getLanguage(); // fallback to stored preference
+  const currentConversationId = storage.getCurrentConversationId();
+  if (currentConversationId) {
+    const allConversations = storage.getAllConversations();
+    const currentConversation = allConversations.find((c) => c.id === currentConversationId);
+    if (currentConversation) {
+      initialLanguage = currentConversation.languageCode;
+    }
+  }
+  
+  return {
+    connectionStatus: 'connecting',
+    currentLanguage: initialLanguage,
+    uiLanguage: storage.getUiLanguage() || 'es',
+    availableLanguages: [],
+    chatHistory: [],
+    currentTranscript: '',
+    pendingTranscription: null,
+    streamingLLMResponse: '',
+    llmResponseComplete: false,
+    currentResponseId: null,
+    isRecording: false,
+    speechDetected: false,
+    flashcards: [],
+    pronouncingCardId: null,
+    feedbackMap: {},
+    userId: null,
+    conversations: [],
+    currentConversationId: null,
+    sidebarOpen: false,
+    switchingConversation: false,
+  };
+};
 
 // Reducer
 function appReducer(state: AppState, action: AppAction): AppState {
@@ -262,6 +275,7 @@ export function AppProvider({ children }: AppProviderProps) {
   const ttsAudioPlayerInstance = useMemo(() => new AudioPlayer(), []);
   const ttsAudioPlayerRef = useRef(ttsAudioPlayerInstance);
   const hasMigratedRef = useRef(false);
+  const conversationsLoadedRef = useRef(false);
 
   const [state, dispatch] = useReducer(
     appReducer,
@@ -307,35 +321,23 @@ export function AppProvider({ children }: AppProviderProps) {
                 type: 'SET_CONVERSATIONS',
                 payload: allConversations,
               });
-              // Load the most recent conversation
-              const mostRecent = allConversations[0];
-              dispatch({
-                type: 'SET_CURRENT_CONVERSATION_ID',
-                payload: mostRecent.id,
-              });
-              // Update language to match the most recent conversation
-              if (
-                mostRecent.languageCode !== stateRef.current.currentLanguage
-              ) {
-                dispatch({
-                  type: 'SET_LANGUAGE',
-                  payload: mostRecent.languageCode,
-                });
-                storage.saveLanguage(mostRecent.languageCode);
+              
+              // Get the stored current conversation ID
+              let currentId = storage.getCurrentConversationId();
+
+              // If we have a stored conversation ID, verify it exists
+              if (currentId) {
+                const conversationExists = allConversations.find((c) => c.id === currentId);
+                if (!conversationExists) {
+                  // Stored conversation ID doesn't exist anymore, clear it
+                  currentId = null;
+                }
               }
-              const convData = storage.getConversation(mostRecent.id);
-              if (convData) {
-                const chatHistory = convData.messages.map((m) => ({
-                  role: m.role === 'user' ? 'learner' : 'teacher',
-                  content: m.content,
-                })) as ChatMessage[];
-                dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
+
+              // If no stored conversation found, use the most recent one
+              if (!currentId && allConversations.length > 0) {
+                currentId = allConversations[0].id;
               }
-              // Load flashcards for the most recent conversation
-              const flashcards = storage.getFlashcardsForConversation(
-                mostRecent.id
-              );
-              dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
             }
             // Also migrate any local data that isn't in Supabase yet
             return storage.migrateToSupabase(langsToSync);
@@ -348,6 +350,7 @@ export function AppProvider({ children }: AppProviderProps) {
 
       storage.clearSupabaseClient();
       hasMigratedRef.current = false;
+      conversationsLoadedRef.current = false;
     }
   }, [supabase, user]);
 
@@ -364,6 +367,7 @@ export function AppProvider({ children }: AppProviderProps) {
   const processPendingFlashcardsRef = useRef<(conversationId: string) => void>(
     () => {}
   );
+  const selectConversationRef = useRef<(conversationId: string) => void>(() => {});
 
   // Initialize audio players
   useEffect(() => {
@@ -378,50 +382,24 @@ export function AppProvider({ children }: AppProviderProps) {
   }, []);
 
   // Load initial state (conversations across all languages)
+  // Only run if Supabase sync hasn't already loaded conversations
   useEffect(() => {
+    if (conversationsLoadedRef.current) {
+      return; // Supabase sync already loaded conversations
+    }
+    
     const storage = storageRef.current;
-    const currentLang = stateRef.current.currentLanguage;
 
     // Load ALL conversations across all languages
     const allConversations = storage.getAllConversations();
     dispatch({ type: 'SET_CONVERSATIONS', payload: allConversations });
 
-    // Load current conversation or use the most recent one
-    let currentId = storage.getCurrentConversationId(currentLang);
-    if (!currentId && allConversations.length > 0) {
-      currentId = allConversations[0].id;
-      // Update language to match the most recent conversation
-      const mostRecentConvo = allConversations[0];
-      if (mostRecentConvo.languageCode !== currentLang) {
-        dispatch({
-          type: 'SET_LANGUAGE',
-          payload: mostRecentConvo.languageCode,
-        });
-        storage.saveLanguage(mostRecentConvo.languageCode);
-      }
-      storage.setCurrentConversationId(mostRecentConvo.languageCode, currentId);
-    }
-
-    if (currentId) {
-      dispatch({ type: 'SET_CURRENT_CONVERSATION_ID', payload: currentId });
-      const conversationData = storage.getConversation(currentId);
-      if (conversationData) {
-        // Convert backend format to UI format
-        const chatHistory = conversationData.messages.map((m) => ({
-          role: m.role === 'user' ? 'learner' : 'teacher',
-          content: m.content,
-        })) as ChatMessage[];
-        dispatch({ type: 'SET_CHAT_HISTORY', payload: chatHistory });
-
-        // Load flashcards for this specific conversation
-        const flashcards = storage.getFlashcardsForConversation(currentId);
-        dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
-      }
-    } else {
-      // No conversations yet - clear flashcards
+    // If no conversations, clear flashcards
+    if (allConversations.length === 0) {
       dispatch({ type: 'SET_FLASHCARDS', payload: [] });
+      conversationsLoadedRef.current = true;
     }
-  }, []); // Run only once on mount
+  }, []); // Run once on mount
 
   // Save chat history to current conversation when it changes
   useEffect(() => {
@@ -451,11 +429,16 @@ export function AppProvider({ children }: AppProviderProps) {
             payload: data.languages,
           });
 
+          // Don't reset language if we have a current conversation - let selectConversation handle it
+          // Only validate if we don't have a conversation loaded yet
           const currentLang = stateRef.current.currentLanguage;
+          const hasCurrentConversation = !!stateRef.current.currentConversationId;
           const isValidLanguage = data.languages.some(
             (lang: Language) => lang.code === currentLang
           );
-          if (!isValidLanguage) {
+          // Only reset language if it's invalid AND we don't have a current conversation
+          // (if we have a conversation, selectConversation will set the correct language)
+          if (!isValidLanguage && !hasCurrentConversation) {
             dispatch({
               type: 'SET_LANGUAGE',
               payload: data.defaultLanguage || 'es',
@@ -500,10 +483,7 @@ export function AppProvider({ children }: AppProviderProps) {
         type: 'SET_CURRENT_CONVERSATION_ID',
         payload: newConversation.id,
       });
-      storage.setCurrentConversationId(
-        currentState.currentLanguage,
-        newConversation.id
-      );
+      storage.setCurrentConversationId(newConversation.id);
       // Process any flashcards that arrived before conversation was created
       processPendingFlashcardsRef.current(newConversation.id);
     } else if (conversationId) {
@@ -1038,7 +1018,7 @@ export function AppProvider({ children }: AppProviderProps) {
         type: 'SET_CURRENT_CONVERSATION_ID',
         payload: conversationId,
       });
-      storage.setCurrentConversationId(languageCode, conversationId);
+      storage.setCurrentConversationId(conversationId);
 
       // Load flashcards for this specific conversation
       const flashcards = storage.getFlashcardsForConversation(conversationId);
@@ -1097,6 +1077,8 @@ export function AppProvider({ children }: AppProviderProps) {
           timezone: tz,
           // Use auth user ID - will be null if not authenticated
           userId: user?.id || null,
+          // Send current language so backend initializes with correct language
+          languageCode: state.currentLanguage,
         });
       } catch {
         // ignore
@@ -1162,10 +1144,7 @@ export function AppProvider({ children }: AppProviderProps) {
           type: 'SET_CURRENT_CONVERSATION_ID',
           payload: newConversation.id,
         });
-        storage.setCurrentConversationId(
-          stateRef.current.currentLanguage,
-          newConversation.id
-        );
+        storage.setCurrentConversationId(newConversation.id);
         // Process any flashcards that arrived before conversation was created
         processPendingFlashcardsRef.current(newConversation.id);
       } else {
@@ -1278,6 +1257,13 @@ export function AppProvider({ children }: AppProviderProps) {
       const targetLanguage =
         conversation?.languageCode || state.currentLanguage;
 
+      // Set language immediately (before waiting for backend response)
+      // This ensures the language is correct right away, especially on page refresh
+      if (targetLanguage !== state.currentLanguage) {
+        dispatch({ type: 'SET_LANGUAGE', payload: targetLanguage });
+        storage.saveLanguage(targetLanguage);
+      }
+
       // Load the selected conversation data
       const conversationData = storage.getConversation(conversationId);
 
@@ -1309,11 +1295,6 @@ export function AppProvider({ children }: AppProviderProps) {
         
         // UI will be updated when conversation_ready is received
       } else {
-        // If not connected, update UI immediately
-        if (targetLanguage !== state.currentLanguage) {
-          dispatch({ type: 'SET_LANGUAGE', payload: targetLanguage });
-          storage.saveLanguage(targetLanguage);
-        }
 
         if (conversationData) {
           const chatHistory = conversationData.messages.map((m) => ({
@@ -1329,7 +1310,7 @@ export function AppProvider({ children }: AppProviderProps) {
           type: 'SET_CURRENT_CONVERSATION_ID',
           payload: conversationId,
         });
-        storage.setCurrentConversationId(targetLanguage, conversationId);
+        storage.setCurrentConversationId(conversationId);
 
         const flashcards = storage.getFlashcardsForConversation(conversationId);
         dispatch({ type: 'SET_FLASHCARDS', payload: flashcards });
@@ -1352,6 +1333,38 @@ export function AppProvider({ children }: AppProviderProps) {
     ]
   );
 
+  // Update ref so initialization can call selectConversation
+  useEffect(() => {
+    selectConversationRef.current = selectConversation;
+    
+    // If conversations haven't been loaded yet and we have conversations in state, load the current one
+    if (!conversationsLoadedRef.current && state.conversations.length > 0 && selectConversationRef.current) {
+      const storage = storageRef.current;
+      
+      // Get the stored current conversation ID
+      let currentId = storage.getCurrentConversationId();
+      
+      // If we have a stored conversation ID, verify it exists
+      if (currentId) {
+        const conversationExists = state.conversations.find((c) => c.id === currentId);
+        if (!conversationExists) {
+          currentId = null;
+        }
+      }
+      
+      // If no stored conversation found, use the most recent one
+      if (!currentId && state.conversations.length > 0) {
+        currentId = state.conversations[0].id;
+      }
+      
+      // Use selectConversation to load the conversation
+      if (currentId) {
+        selectConversationRef.current(currentId);
+        conversationsLoadedRef.current = true;
+      }
+    }
+  }, [selectConversation, state.conversations]);
+
   // Create a new conversation
   const createNewConversation = useCallback(() => {
     const storage = storageRef.current;
@@ -1398,10 +1411,7 @@ export function AppProvider({ children }: AppProviderProps) {
       type: 'SET_CURRENT_CONVERSATION_ID',
       payload: newConversation.id,
     });
-    storage.setCurrentConversationId(
-      languageForNewConversation,
-      newConversation.id
-    );
+    storage.setCurrentConversationId(newConversation.id);
 
     // Clear chat and flashcards (new conversation has no flashcards)
     dispatch({ type: 'RESET_CONVERSATION' });
diff --git a/frontend/src/services/Storage.ts b/frontend/src/services/Storage.ts
index 33bea18..1fe1c36 100644
--- a/frontend/src/services/Storage.ts
+++ b/frontend/src/services/Storage.ts
@@ -11,11 +11,11 @@ export class Storage {
   private conversationKey = 'aprende-conversation-history'; // Legacy single conversation
   private conversationsListKeyPrefix = 'aprende-conversations-'; // + languageCode
   private conversationDataKeyPrefix = 'aprende-conversation-'; // + conversationId
-  private currentConversationKeyPrefix = 'aprende-current-conversation-'; // + languageCode
   private flashcardsKey = 'aprende-flashcards'; // Legacy per-language flashcards
   private flashcardsConversationKeyPrefix = 'aprende-flashcards-conv-'; // + conversationId
   private languageKey = 'aprende-language';
   private uiLanguageKey = 'aprende-ui-language';
+  private currentConversationKey = 'aprende-current-conversation';
 
   // Language preference methods
   getLanguage(): string {
@@ -194,7 +194,7 @@ export class Storage {
             JSON.stringify(conversationData)
           );
           localStorage.setItem(
-            this.currentConversationKeyPrefix + languageCode,
+            this.currentConversationKey,
             conversationId
           );
 
@@ -301,11 +301,9 @@ export class Storage {
       );
 
       // If this was the current conversation, clear current
-      const currentId = this.getCurrentConversationId(languageCode);
+      const currentId = this.getCurrentConversationId();
       if (currentId === conversationId) {
-        localStorage.removeItem(
-          this.currentConversationKeyPrefix + languageCode
-        );
+        localStorage.removeItem(this.currentConversationKey);
       }
     } catch (error) {
       console.error('Failed to delete conversation:', error);
@@ -333,22 +331,17 @@ export class Storage {
     }
   }
 
-  getCurrentConversationId(languageCode: string): string | null {
+  getCurrentConversationId(): string | null {
     try {
-      return localStorage.getItem(
-        this.currentConversationKeyPrefix + languageCode
-      );
+      return localStorage.getItem(this.currentConversationKey);
     } catch {
       return null;
     }
   }
 
-  setCurrentConversationId(languageCode: string, conversationId: string): void {
+  setCurrentConversationId(conversationId: string): void {
     try {
-      localStorage.setItem(
-        this.currentConversationKeyPrefix + languageCode,
-        conversationId
-      );
+      localStorage.setItem(this.currentConversationKey, conversationId);
     } catch (error) {
       console.error('Failed to set current conversation:', error);
     }

From 6faf31640c20cd4f02d39283d6831b2545a87a14 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Thu, 22 Jan 2026 12:18:20 -0800
Subject: [PATCH 48/49] update readme and update to tts-1.5-max

---
 README.md                                     | 24 ++++++++++++-------
 backend/.env.example                          |  5 ++++
 backend/package-lock.json                     | 10 --------
 backend/src/config/languages.ts               | 12 +++++-----
 .../lang-learning-conversation-graph.json     |  4 ++--
 frontend/package-lock.json                    | 16 -------------
 6 files changed, 29 insertions(+), 42 deletions(-)
 create mode 100644 backend/.env.example

diff --git a/README.md b/README.md
index 1a52eaa..c46a912 100644
--- a/README.md
+++ b/README.md
@@ -27,13 +27,22 @@ cd language-learning-node
 
 ### Step 2: Install Dependencies
 
+
+Frontend:
+```bash
+cd frontend
+npm install
+```
+
+Backend:
 ```bash
+cd backend
 npm install
 ```
 
 ### Step 3: Configure Environment Variables
 
-Create a `.env` file in the root directory:
+Create a `.env` file in the /backend directory:
 
 ```bash
 INWORLD_API_KEY=your_inworld_base64_key
@@ -49,19 +58,18 @@ ASSEMBLY_AI_API_KEY=your_assemblyai_key
 
 **For development** (with auto-reload on file changes):
 
+In frontend dir:
 ```bash
 npm run dev
 ```
 
-Open [http://localhost:3000](http://localhost:3000)
-
-**For production**:
-
+In backend dir:
 ```bash
-npm run build
-npm start
+npm run dev
 ```
 
+Open [http://localhost:5173](http://localhost:5173)
+
 ### Step 5 (Optional): Set Up Supabase for Auth & Memory
 
 Without Supabase, the app works in anonymous mode using localStorage.
@@ -80,7 +88,7 @@ This creates all tables, indexes, RLS policies, and the `match_memories` functio
 
 Find your project ref in the Supabase dashboard URL: `supabase.com/dashboard/project/YOUR_PROJECT_REF`
 
-**c) Add Supabase variables to `.env` (root):**
+**c) Add Supabase variables to `.env` (backend):**
 
 ```bash
 SUPABASE_URL=https://YOUR_PROJECT.supabase.co
diff --git a/backend/.env.example b/backend/.env.example
new file mode 100644
index 0000000..41a06c1
--- /dev/null
+++ b/backend/.env.example
@@ -0,0 +1,5 @@
+INWORLD_API_KEY=
+ASSEMBLY_AI_API_KEY=
+
+SUPABASE_URL=
+SUPABASE_SERVICE_ROLE_KEY=
\ No newline at end of file
diff --git a/backend/package-lock.json b/backend/package-lock.json
index 0f6c63d..22d389d 100644
--- a/backend/package-lock.json
+++ b/backend/package-lock.json
@@ -1695,7 +1695,6 @@
       "integrity": "sha512-tK3GPFWbirvNgsNKto+UmB/cRtn6TZfyw0D6IKrW55n6Vbs7KJoZtI//kpTKzE/DUmmnAFD8/Ca46s7Obs92/w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.46.4",
         "@typescript-eslint/types": "8.46.4",
@@ -2191,7 +2190,6 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -3222,7 +3220,6 @@
       "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -3283,7 +3280,6 @@
       "integrity": "sha512-iI1f+D2ViGn+uvv5HuHVUamg8ll4tN+JRHGc6IJi4TP9Kl976C57fzPXgseXNs8v0iA8aSJpHsTWjDb9QJamGQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -5343,7 +5339,6 @@
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -6293,7 +6288,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -6394,7 +6388,6 @@
       "integrity": "sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "~0.25.0",
         "get-tsconfig": "^4.7.5"
@@ -6455,7 +6448,6 @@
       "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -7150,7 +7142,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -7164,7 +7155,6 @@
       "integrity": "sha512-E4t7DJ9pESL6E3I8nFjPa4xGUd3PmiWDLsDztS2qXSJWfHtbQnwAWylaBvSNY48I3vr8PTqIZlyK8TE3V3CA4Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@vitest/expect": "4.0.16",
         "@vitest/mocker": "4.0.16",
diff --git a/backend/src/config/languages.ts b/backend/src/config/languages.ts
index 266a287..54a0953 100644
--- a/backend/src/config/languages.ts
+++ b/backend/src/config/languages.ts
@@ -66,7 +66,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'en-US',
     ttsConfig: {
       speakerId: 'Ashley',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'en-US',
@@ -95,7 +95,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'es-MX', // Mexican Spanish
     ttsConfig: {
       speakerId: 'Diego',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'es-MX',
@@ -124,7 +124,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'fr-FR',
     ttsConfig: {
       speakerId: 'Alain',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'fr-FR',
@@ -154,7 +154,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'de-DE',
     ttsConfig: {
       speakerId: 'Josef',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 0.7,
       languageCode: 'de-DE',
@@ -184,7 +184,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'it-IT',
     ttsConfig: {
       speakerId: 'Orietta',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'it-IT',
@@ -214,7 +214,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'pt-BR', // Brazilian Portuguese
     ttsConfig: {
       speakerId: 'Heitor',
-      modelId: 'inworld-tts-1',
+      modelId: 'inworld-tts-1-max',
       speakingRate: 1,
       temperature: 0.7,
       languageCode: 'pt-BR',
diff --git a/backend/src/graphs/configs/lang-learning-conversation-graph.json b/backend/src/graphs/configs/lang-learning-conversation-graph.json
index 4c34e49..1a4c52c 100644
--- a/backend/src/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/src/graphs/configs/lang-learning-conversation-graph.json
@@ -139,7 +139,7 @@
             "synthesis_config": {
               "type": "inworld",
               "config": {
-                "model_id": "inworld-tts-1",
+                "model_id": "inworld-tts-1-max",
                 "inference": {
                   "speaking_rate": 1,
                   "temperature": 1.1
@@ -263,7 +263,7 @@
           "synthesis_config": {
             "type": "inworld",
             "config": {
-              "model_id": "inworld-tts-1",
+              "model_id": "inworld-tts-1-max",
               "inference": {
                 "speaking_rate": 1,
                 "temperature": 1.1
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 5d0a7b8..8b55696 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -84,7 +84,6 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -424,7 +423,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -448,7 +446,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1667,7 +1664,6 @@
       "integrity": "sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1736,7 +1732,6 @@
       "integrity": "sha512-3xP4XzzDNQOIqBMWogftkwxhg5oMKApqY0BAflmLZiFYHqyhSOxv/cd/zPQLTcCXr4AkaKb25joocY0BD1WC6A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.51.0",
         "@typescript-eslint/types": "8.51.0",
@@ -2099,7 +2094,6 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2232,7 +2226,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -2627,7 +2620,6 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -2688,7 +2680,6 @@
       "integrity": "sha512-iI1f+D2ViGn+uvv5HuHVUamg8ll4tN+JRHGc6IJi4TP9Kl976C57fzPXgseXNs8v0iA8aSJpHsTWjDb9QJamGQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -3330,7 +3321,6 @@
       "integrity": "sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssstyle": "^4.1.0",
         "data-urls": "^5.0.0",
@@ -3700,7 +3690,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -3753,7 +3742,6 @@
       "integrity": "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -3792,7 +3780,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
       "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -4145,7 +4132,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -4231,7 +4217,6 @@
       "integrity": "sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.27.0",
         "fdir": "^6.5.0",
@@ -4547,7 +4532,6 @@
       "integrity": "sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }

From c69c7cecf5f6dda30e29d55975e91911e3f979c6 Mon Sep 17 00:00:00 2001
From: Cale Shapera <25466659+cshape@users.noreply.github.com>
Date: Thu, 22 Jan 2026 12:38:49 -0800
Subject: [PATCH 49/49] readme and migrations cleanup

---
 README.md                                     | 33 ++++++++++---------
 backend/src/config/languages.ts               | 12 +++----
 .../lang-learning-conversation-graph.json     |  4 +--
 .../20240108000000_initial_schema.sql         | 11 ++++---
 4 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index c46a912..281130a 100644
--- a/README.md
+++ b/README.md
@@ -109,30 +109,33 @@ Find these in: Supabase Dashboard > Settings > API
 ```
 language-learning-node/
 ├── backend/
-│   ├── __tests__/            # Backend unit tests
-│   ├── config/               # Language & server configuration
-│   ├── graphs/               # Inworld Runtime conversation graphs
-│   │   ├── configs/          # Graph JSON configurations
-│   │   └── nodes/            # Custom graph nodes (STT, TTS, etc.)
-│   ├── helpers/              # Audio utils, connection management, etc.
-│   ├── prompts/              # Nunjucks prompt templates
-│   ├── services/             # Server components
-│   ├── utils/                # Logger
-│   └── server.ts             # Express + WebSocket server entry point
+│   ├── src/
+│   │   ├── __tests__/        # Backend unit tests
+│   │   ├── config/           # Language & server configuration
+│   │   ├── graphs/           # Inworld Runtime conversation graphs
+│   │   │   ├── configs/      # Graph JSON configurations
+│   │   │   └── nodes/        # Custom graph nodes
+│   │   ├── helpers/          # Audio utils, connection management
+│   │   ├── prompts/          # Nunjucks prompt templates
+│   │   ├── services/         # Server components
+│   │   ├── utils/            # Logger
+│   │   └── server.ts         # Entry point
+│   ├── .env                  # Backend environment variables
+│   └── vitest.config.ts      # Backend test config
 ├── frontend/
 │   ├── src/
 │   │   ├── __tests__/        # Frontend unit tests
 │   │   ├── components/       # React components
-│   │   ├── context/          # App state & auth (React Context)
+│   │   ├── context/          # App state & auth
 │   │   ├── hooks/            # Custom React hooks
 │   │   ├── services/         # WebSocket client, audio, storage
 │   │   ├── styles/           # CSS
 │   │   └── types/            # TypeScript types
+│   ├── .env.local            # Frontend environment variables
 │   └── vitest.config.ts      # Frontend test config
-├── supabase/                 # Database migrations (optional)
-├── deploy/                   # Deployment configurations
-├── package.json
-└── .env                      # Environment variables
+├── supabase/
+│   └── migrations/           # Database schema
+└── deploy/                   # Deployment configurations
 ```
 
 ## Architecture
diff --git a/backend/src/config/languages.ts b/backend/src/config/languages.ts
index 54a0953..b79fe8e 100644
--- a/backend/src/config/languages.ts
+++ b/backend/src/config/languages.ts
@@ -66,7 +66,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'en-US',
     ttsConfig: {
       speakerId: 'Ashley',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'en-US',
@@ -95,7 +95,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'es-MX', // Mexican Spanish
     ttsConfig: {
       speakerId: 'Diego',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'es-MX',
@@ -124,7 +124,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'fr-FR',
     ttsConfig: {
       speakerId: 'Alain',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'fr-FR',
@@ -154,7 +154,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'de-DE',
     ttsConfig: {
       speakerId: 'Josef',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 0.7,
       languageCode: 'de-DE',
@@ -184,7 +184,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'it-IT',
     ttsConfig: {
       speakerId: 'Orietta',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 1.1,
       languageCode: 'it-IT',
@@ -214,7 +214,7 @@ export const SUPPORTED_LANGUAGES: Record<string, LanguageConfig> = {
     sttLanguageCode: 'pt-BR', // Brazilian Portuguese
     ttsConfig: {
       speakerId: 'Heitor',
-      modelId: 'inworld-tts-1-max',
+      modelId: 'inworld-tts-1.5-max',
       speakingRate: 1,
       temperature: 0.7,
       languageCode: 'pt-BR',
diff --git a/backend/src/graphs/configs/lang-learning-conversation-graph.json b/backend/src/graphs/configs/lang-learning-conversation-graph.json
index 1a4c52c..43f141d 100644
--- a/backend/src/graphs/configs/lang-learning-conversation-graph.json
+++ b/backend/src/graphs/configs/lang-learning-conversation-graph.json
@@ -139,7 +139,7 @@
             "synthesis_config": {
               "type": "inworld",
               "config": {
-                "model_id": "inworld-tts-1-max",
+                "model_id": "inworld-tts-1.5-max",
                 "inference": {
                   "speaking_rate": 1,
                   "temperature": 1.1
@@ -263,7 +263,7 @@
           "synthesis_config": {
             "type": "inworld",
             "config": {
-              "model_id": "inworld-tts-1-max",
+              "model_id": "inworld-tts-1.5-max",
               "inference": {
                 "speaking_rate": 1,
                 "temperature": 1.1
diff --git a/supabase/migrations/20240108000000_initial_schema.sql b/supabase/migrations/20240108000000_initial_schema.sql
index 843230e..090a89d 100644
--- a/supabase/migrations/20240108000000_initial_schema.sql
+++ b/supabase/migrations/20240108000000_initial_schema.sql
@@ -80,6 +80,7 @@ create table public.user_memories (
 create index idx_conversations_user_lang on public.conversations(user_id, language_code, updated_at desc);
 create index idx_messages_conversation on public.conversation_messages(conversation_id, created_at);
 create index idx_flashcards_conversation on public.flashcards(user_id, conversation_id);
+create index idx_flashcards_conversation_id on public.flashcards(conversation_id);
 
 -- Memory indexes
 create index idx_memories_embedding on public.user_memories
@@ -98,12 +99,12 @@ alter table public.user_memories enable row level security;
 
 -- RLS Policies (users can only access their own data)
 -- Note: Service role key bypasses RLS, which is what the backend uses
-create policy "Users manage own preferences" on public.user_preferences for all using (auth.uid() = user_id);
-create policy "Users manage own conversations" on public.conversations for all using (auth.uid() = user_id);
+create policy "Users manage own preferences" on public.user_preferences for all using ((select auth.uid()) = user_id);
+create policy "Users manage own conversations" on public.conversations for all using ((select auth.uid()) = user_id);
 create policy "Users manage own messages" on public.conversation_messages for all
-  using (conversation_id in (select id from public.conversations where user_id = auth.uid()));
-create policy "Users manage own flashcards" on public.flashcards for all using (auth.uid() = user_id);
-create policy "Users manage own memories" on public.user_memories for all using (auth.uid() = user_id);
+  using (conversation_id in (select id from public.conversations where user_id = (select auth.uid())));
+create policy "Users manage own flashcards" on public.flashcards for all using ((select auth.uid()) = user_id);
+create policy "Users manage own memories" on public.user_memories for all using ((select auth.uid()) = user_id);
 
 --------------------------------------------------------------------------------
 -- Functions