opencode-smart-voice-notify 1.1.2 → 1.2.2

package/README.md

@@ -35,6 +35,13 @@ The plugin automatically tries multiple TTS engines in order, falling back if on
 - **Permission Batching**: Multiple simultaneous permission requests are batched into a single notification (e.g., "5 permission requests require your attention")
 - **Question Tool Support** (SDK v1.1.7+): Notifies when the agent asks questions and needs user input
 
+### AI-Generated Messages (Experimental)
+- **Dynamic notifications**: Use a local AI to generate unique, contextual messages instead of preset static ones
+- **OpenAI-compatible**: Works with Ollama, LM Studio, LocalAI, vLLM, llama.cpp, Jan.ai, or any OpenAI-compatible endpoint
+- **User-hosted**: You provide your own AI endpoint - no cloud API keys required
+- **Custom prompts**: Configure prompts per notification type for full control over AI personality
+- **Smart fallback**: Automatically falls back to static messages if AI is unavailable
+
 ### System Integration
 - **Native Edge TTS**: No external dependencies (Python/pip) required
 - Wake monitor from sleep before notifying
@@ -383,8 +390,40 @@ If you prefer to create the config manually, add a `smart-voice-notify.jsonc` fi
 }
 ```
 
-See `example.config.jsonc` for more details.
-
+See `example.config.jsonc` for more details.
+
+### AI Message Generation (Optional)
+
+If you want dynamic, AI-generated notification messages instead of preset ones, you can connect to a local AI server:
+
+1. **Install a local AI server** (e.g., [Ollama](https://ollama.ai)):
+   ```bash
+   # Install Ollama and pull a model
+   ollama pull llama3
+   ```
+
+2. **Enable AI messages in your config**:
+   ```jsonc
+   {
+     "enableAIMessages": true,
+     "aiEndpoint": "http://localhost:11434/v1",
+     "aiModel": "llama3",
+     "aiApiKey": "",
+     "aiFallbackToStatic": true
+   }
+   ```
+
+3. **The AI will generate unique messages** for each notification, which are then spoken by your TTS engine.
+
+**Supported AI Servers:**
+| Server | Default Endpoint | API Key |
+|--------|-----------------|---------|
+| Ollama | `http://localhost:11434/v1` | Not needed |
+| LM Studio | `http://localhost:1234/v1` | Not needed |
+| LocalAI | `http://localhost:8080/v1` | Not needed |
+| vLLM | `http://localhost:8000/v1` | Use "EMPTY" |
+| Jan.ai | `http://localhost:1337/v1` | Required |
+
 ## Requirements
 
 ### For ElevenLabs TTS

package/example.config.jsonc

@@ -250,6 +250,71 @@
     // Question batch window (ms) - how long to wait for more questions before notifying
     "questionBatchWindowMs": 800,
     
+    // ============================================================
+    // AI MESSAGE GENERATION (OpenAI-Compatible Endpoints)
+    // ============================================================
+    // Use a local/self-hosted AI to generate dynamic notification messages
+    // instead of using preset static messages. The AI generates the text,
+    // which is then spoken by your configured TTS engine (ElevenLabs, Edge, etc.)
+    //
+    // Supports: Ollama, LM Studio, LocalAI, vLLM, llama.cpp, Jan.ai, and any
+    // OpenAI-compatible endpoint. You provide your own endpoint URL and API key.
+    //
+    // HOW IT WORKS:
+    //   1. When a notification is triggered (task complete, permission needed, etc.)
+    //   2. If AI is enabled, the plugin sends a prompt to your AI server
+    //   3. The AI generates a unique, contextual notification message
+    //   4. That message is spoken by your TTS engine (ElevenLabs, Edge, SAPI)
+    //   5. If AI fails, it falls back to the static messages defined above
+    
+    // Enable AI-generated messages (experimental feature)
+    // Default: false (uses static messages defined above)
+    "enableAIMessages": false,
+    
+    // Your AI server endpoint URL
+    // Common local AI servers and their default endpoints:
+    //   Ollama:         http://localhost:11434/v1
+    //   LM Studio:      http://localhost:1234/v1
+    //   LocalAI:        http://localhost:8080/v1
+    //   vLLM:           http://localhost:8000/v1
+    //   llama.cpp:      http://localhost:8080/v1
+    //   Jan.ai:         http://localhost:1337/v1
+    //   text-gen-webui: http://localhost:5000/v1
+    "aiEndpoint": "http://localhost:11434/v1",
+    
+    // Model name to use (must match a model loaded in your AI server)
+    // Examples for Ollama: "llama3", "llama3.2", "mistral", "phi3", "gemma2", "qwen2"
+    // For LM Studio: Use the model name shown in the UI
+    "aiModel": "llama3",
+    
+    // API key for your AI server
+    // Most local servers (Ollama, LM Studio, LocalAI) don't require a key - leave empty
+    // Only set this if your server requires authentication
+    // For vLLM with auth disabled, use "EMPTY"
+    "aiApiKey": "",
+    
+    // Request timeout in milliseconds
+    // Local AI can be slow on first request (model loading), so 15 seconds is recommended
+    // Increase if you have a slower machine or larger models
+    "aiTimeout": 15000,
+    
+    // Fall back to static messages (defined above) if AI generation fails
+    // Recommended: true - ensures notifications always work even if AI is down
+    "aiFallbackToStatic": true,
+    
+    // Custom prompts for each notification type
+    // You can customize these to change the AI's personality/style
+    // The AI will generate a short message based on these prompts
+    // TIP: Keep prompts concise - they're sent with each notification
+    "aiPrompts": {
+        "idle": "Generate a single brief, friendly notification sentence (max 15 words) saying a coding task is complete. Be encouraging and warm. Output only the message, no quotes.",
+        "permission": "Generate a single brief, urgent but friendly notification sentence (max 15 words) asking the user to approve a permission request. Output only the message, no quotes.",
+        "question": "Generate a single brief, polite notification sentence (max 15 words) saying the assistant has a question and needs user input. Output only the message, no quotes.",
+        "idleReminder": "Generate a single brief, gentle reminder sentence (max 15 words) that a completed task is waiting for review. Be slightly more insistent. Output only the message, no quotes.",
+        "permissionReminder": "Generate a single brief, urgent reminder sentence (max 15 words) that permission approval is still needed. Convey importance. Output only the message, no quotes.",
+        "questionReminder": "Generate a single brief, polite but persistent reminder sentence (max 15 words) that a question is still waiting for an answer. Output only the message, no quotes."
+    },
+    
     // ============================================================
     // SOUND FILES (For immediate notifications)
     // These are played first before TTS reminder kicks in

package/index.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { createTTS, getTTSConfig } from './util/tts.js';
+import { getSmartMessage } from './util/ai-messages.js';
 
 /**
  * OpenCode Smart Voice Notify Plugin
@@ -251,11 +252,11 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
         const storedCount = reminder?.itemCount || 1;
         let reminderMessage;
         if (type === 'permission') {
-          reminderMessage = getPermissionMessage(storedCount, true);
+          reminderMessage = await getPermissionMessage(storedCount, true);
         } else if (type === 'question') {
-          reminderMessage = getQuestionMessage(storedCount, true);
+          reminderMessage = await getQuestionMessage(storedCount, true);
         } else {
-          reminderMessage = getRandomMessage(config.idleReminderTTSMessages);
+          reminderMessage = await getSmartMessage('idle', true, config.idleReminderTTSMessages);
         }
 
         // Check for ElevenLabs API key configuration issues
@@ -305,11 +306,11 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
               const followUpStoredCount = followUpReminder?.itemCount || 1;
               let followUpMessage;
               if (type === 'permission') {
-                followUpMessage = getPermissionMessage(followUpStoredCount, true);
+                followUpMessage = await getPermissionMessage(followUpStoredCount, true);
               } else if (type === 'question') {
-                followUpMessage = getQuestionMessage(followUpStoredCount, true);
+                followUpMessage = await getQuestionMessage(followUpStoredCount, true);
               } else {
-                followUpMessage = getRandomMessage(config.idleReminderTTSMessages);
+                followUpMessage = await getSmartMessage('idle', true, config.idleReminderTTSMessages);
               }
               
               await tts.wakeMonitor();
@@ -356,8 +357,8 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
       soundLoops = 1,
       ttsMessage,
       fallbackSound,
-      permissionCount = 1,  // Support permission count for batched notifications
-      questionCount = 1     // Support question count for batched notifications
+      permissionCount,  // Support permission count for batched notifications
+      questionCount       // Support question count for batched notifications
     } = options;
 
     // Step 1: Play the immediate sound notification
@@ -391,11 +392,11 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
     if (config.notificationMode === 'tts-first' || config.notificationMode === 'both') {
       let immediateMessage;
       if (type === 'permission') {
-        immediateMessage = getRandomMessage(config.permissionTTSMessages);
+        immediateMessage = await getSmartMessage('permission', false, config.permissionTTSMessages);
       } else if (type === 'question') {
-        immediateMessage = getRandomMessage(config.questionTTSMessages);
+        immediateMessage = await getSmartMessage('question', false, config.questionTTSMessages);
       } else {
-        immediateMessage = getRandomMessage(config.idleTTSMessages);
+        immediateMessage = await getSmartMessage('idle', false, config.idleTTSMessages);
       }
       
       await tts.speak(immediateMessage, {
@@ -407,69 +408,88 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
 
   /**
    * Get a count-aware TTS message for permission requests
+   * Uses AI generation when enabled, falls back to static messages
    * @param {number} count - Number of permission requests
    * @param {boolean} isReminder - Whether this is a reminder message
-   * @returns {string} The formatted message
+   * @returns {Promise<string>} The formatted message
    */
-  const getPermissionMessage = (count, isReminder = false) => {
+  const getPermissionMessage = async (count, isReminder = false) => {
     const messages = isReminder 
       ? config.permissionReminderTTSMessages 
       : config.permissionTTSMessages;
     
+    // If AI messages are enabled, ALWAYS try AI first (regardless of count)
+    if (config.enableAIMessages) {
+      const aiMessage = await getSmartMessage('permission', isReminder, messages, { count, type: 'permission' });
+      // getSmartMessage returns static message as fallback, so if AI was attempted
+      // and succeeded, we'll get the AI message. If it failed, we get static.
+      // Check if we got a valid message (not the generic fallback)
+      if (aiMessage && aiMessage !== 'Notification') {
+        return aiMessage;
+      }
+    }
+    
+    // Fallback to static messages (AI disabled or failed with generic fallback)
     if (count === 1) {
-      // Single permission - use regular message
       return getRandomMessage(messages);
     } else {
-      // Multiple permissions - use count-aware messages if available, or format dynamically
       const countMessages = isReminder
         ? config.permissionReminderTTSMessagesMultiple
         : config.permissionTTSMessagesMultiple;
       
       if (countMessages && countMessages.length > 0) {
-        // Use configured multi-permission messages (replace {count} placeholder)
         const template = getRandomMessage(countMessages);
         return template.replace('{count}', count.toString());
-      } else {
-        // Fallback: generate a dynamic message
-        return `Attention! There are ${count} permission requests waiting for your approval.`;
       }
+      return `Attention! There are ${count} permission requests waiting for your approval.`;
     }
   };
 
   /**
    * Get a count-aware TTS message for question requests (SDK v1.1.7+)
+   * Uses AI generation when enabled, falls back to static messages
    * @param {number} count - Number of question requests
    * @param {boolean} isReminder - Whether this is a reminder message
-   * @returns {string} The formatted message
+   * @returns {Promise<string>} The formatted message
    */
-  const getQuestionMessage = (count, isReminder = false) => {
+  const getQuestionMessage = async (count, isReminder = false) => {
     const messages = isReminder 
       ? config.questionReminderTTSMessages 
       : config.questionTTSMessages;
     
+    // If AI messages are enabled, ALWAYS try AI first (regardless of count)
+    if (config.enableAIMessages) {
+      const aiMessage = await getSmartMessage('question', isReminder, messages, { count, type: 'question' });
+      // getSmartMessage returns static message as fallback, so if AI was attempted
+      // and succeeded, we'll get the AI message. If it failed, we get static.
+      // Check if we got a valid message (not the generic fallback)
+      if (aiMessage && aiMessage !== 'Notification') {
+        return aiMessage;
+      }
+    }
+    
+    // Fallback to static messages (AI disabled or failed with generic fallback)
     if (count === 1) {
-      // Single question - use regular message
       return getRandomMessage(messages);
     } else {
-      // Multiple questions - use count-aware messages if available, or format dynamically
       const countMessages = isReminder
         ? config.questionReminderTTSMessagesMultiple
         : config.questionTTSMessagesMultiple;
       
       if (countMessages && countMessages.length > 0) {
-        // Use configured multi-question messages (replace {count} placeholder)
         const template = getRandomMessage(countMessages);
         return template.replace('{count}', count.toString());
-      } else {
-        // Fallback: generate a dynamic message
-        return `Hey! I have ${count} questions for you. Please check your screen.`;
       }
+      return `Hey! I have ${count} questions for you. Please check your screen.`;
     }
   };
 
   /**
    * Process the batched permission requests as a single notification
    * Called after the batch window expires
+   * 
+   * FIX: Play sound IMMEDIATELY before any AI generation to avoid delay.
+   * AI message generation can take 3-15+ seconds, which was delaying sound playback.
    */
   const processPermissionBatch = async () => {
     // Capture and clear the batch
@@ -489,40 +509,42 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
     // We track all IDs in the batch for proper cleanup
     activePermissionId = batch[0];
     
-    // Show toast with count
+    // Step 1: Show toast IMMEDIATELY (fire and forget - no await)
     const toastMessage = batchCount === 1
       ? "⚠️ Permission request requires your attention"
       : `⚠️ ${batchCount} permission requests require your attention`;
-    await showToast(toastMessage, "warning", 8000);
+    showToast(toastMessage, "warning", 8000);  // No await - instant display
+    
+    // Step 2: Play sound (after toast is triggered)
+    const soundLoops = batchCount === 1 ? 2 : Math.min(3, batchCount);
+    await playSound(config.permissionSound, soundLoops);
 
-    // CHECK: Did user already respond while we were showing toast?
+    // CHECK: Did user already respond while sound was playing?
     if (pendingPermissionBatch.length > 0) {
-      // New permissions arrived during toast - they'll be handled in next batch
-      debugLog('processPermissionBatch: new permissions arrived during toast');
+      // New permissions arrived during sound - they'll be handled in next batch
+      debugLog('processPermissionBatch: new permissions arrived during sound');
     }
     
-    // Check if any permission was already replied to
+    // Step 3: Check race condition - did user respond during sound?
     if (activePermissionId === null) {
-      debugLog('processPermissionBatch: aborted - user already responded');
+      debugLog('processPermissionBatch: user responded during sound - aborting');
       return;
     }
 
-    // Get count-aware TTS message
-    const ttsMessage = getPermissionMessage(batchCount, false);
-    const reminderMessage = getPermissionMessage(batchCount, true);
-
-    // Smart notification: sound first, TTS reminder later
-    await smartNotify('permission', {
-      soundFile: config.permissionSound,
-      soundLoops: batchCount === 1 ? 2 : Math.min(3, batchCount), // More loops for more permissions
-      ttsMessage: reminderMessage,
-      fallbackSound: config.permissionSound,
-      // Pass count for potential use in notification
-      permissionCount: batchCount
-    });
+    // Step 4: Generate AI message for reminder AFTER sound played
+    const reminderMessage = await getPermissionMessage(batchCount, true);
     
-    // Speak immediately if in TTS-first or both mode (with count-aware message)
+    // Step 5: Schedule TTS reminder if enabled
+    if (config.enableTTSReminder && reminderMessage) {
+      scheduleTTSReminder('permission', reminderMessage, {
+        fallbackSound: config.permissionSound,
+        permissionCount: batchCount
+      });
+    }
+    
+    // Step 6: If TTS-first or both mode, generate and speak immediate message
     if (config.notificationMode === 'tts-first' || config.notificationMode === 'both') {
+      const ttsMessage = await getPermissionMessage(batchCount, false);
       await tts.wakeMonitor();
       await tts.forceVolume();
       await tts.speak(ttsMessage, {
@@ -541,6 +563,9 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
   /**
    * Process the batched question requests as a single notification (SDK v1.1.7+)
    * Called after the batch window expires
+   * 
+   * FIX: Play sound IMMEDIATELY before any AI generation to avoid delay.
+   * AI message generation can take 3-15+ seconds, which was delaying sound playback.
    */
   const processQuestionBatch = async () => {
     // Capture and clear the batch
@@ -563,41 +588,41 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
     // We track all IDs in the batch for proper cleanup
     activeQuestionId = batch[0]?.id;
     
-    // Show toast with count
+    // Step 1: Show toast IMMEDIATELY (fire and forget - no await)
     const toastMessage = totalQuestionCount === 1
       ? "❓ The agent has a question for you"
       : `❓ The agent has ${totalQuestionCount} questions for you`;
-    await showToast(toastMessage, "info", 8000);
+    showToast(toastMessage, "info", 8000);  // No await - instant display
+    
+    // Step 2: Play sound (after toast is triggered)
+    await playSound(config.questionSound, 2);
 
-    // CHECK: Did user already respond while we were showing toast?
+    // CHECK: Did user already respond while sound was playing?
     if (pendingQuestionBatch.length > 0) {
-      // New questions arrived during toast - they'll be handled in next batch
-      debugLog('processQuestionBatch: new questions arrived during toast');
+      // New questions arrived during sound - they'll be handled in next batch
+      debugLog('processQuestionBatch: new questions arrived during sound');
     }
     
-    // Check if any question was already replied to or rejected
+    // Step 3: Check race condition - did user respond during sound?
     if (activeQuestionId === null) {
-      debugLog('processQuestionBatch: aborted - user already responded');
+      debugLog('processQuestionBatch: user responded during sound - aborting');
       return;
     }
 
-    // Get count-aware TTS message (uses total question count, not request count)
-    const ttsMessage = getQuestionMessage(totalQuestionCount, false);
-    const reminderMessage = getQuestionMessage(totalQuestionCount, true);
-
-    // Smart notification: sound first, TTS reminder later
-    // Sound plays 2 times by default (matching permission behavior)
-    await smartNotify('question', {
-      soundFile: config.questionSound,
-      soundLoops: 2, // Fixed at 2 loops to match permission sound behavior
-      ttsMessage: reminderMessage,
-      fallbackSound: config.questionSound,
-      // Pass count for use in reminders
-      questionCount: totalQuestionCount
-    });
+    // Step 4: Generate AI message for reminder AFTER sound played
+    const reminderMessage = await getQuestionMessage(totalQuestionCount, true);
+
+    // Step 5: Schedule TTS reminder if enabled
+    if (config.enableTTSReminder && reminderMessage) {
+      scheduleTTSReminder('question', reminderMessage, {
+        fallbackSound: config.questionSound,
+        questionCount: totalQuestionCount
+      });
+    }
     
-    // Speak immediately if in TTS-first or both mode (with count-aware message)
+    // Step 6: If TTS-first or both mode, generate and speak immediate message
     if (config.notificationMode === 'tts-first' || config.notificationMode === 'both') {
+      const ttsMessage = await getQuestionMessage(totalQuestionCount, false);
       await tts.wakeMonitor();
       await tts.forceVolume();
       await tts.speak(ttsMessage, {
@@ -736,6 +761,9 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
 
         // ========================================
         // NOTIFICATION 1: Session Idle (Agent Finished)
+        // 
+        // FIX: Play sound IMMEDIATELY before any AI generation to avoid delay.
+        // AI message generation can take 3-15+ seconds, which was delaying sound playback.
         // ========================================
         if (event.type === "session.idle") {
           const sessionID = event.properties?.sessionID;
@@ -753,15 +781,42 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
           lastSessionIdleTime = Date.now();
           
           debugLog(`session.idle: notifying for session ${sessionID} (idleTime=${lastSessionIdleTime})`);
-          await showToast("✅ Agent has finished working", "success", 5000);
-
-          // Smart notification: sound first, TTS reminder later
-          await smartNotify('idle', {
-            soundFile: config.idleSound,
-            soundLoops: 1,
-            ttsMessage: getRandomMessage(config.idleTTSMessages),
-            fallbackSound: config.idleSound
-          });
+          
+          // Step 1: Show toast IMMEDIATELY (fire and forget - no await)
+          showToast("✅ Agent has finished working", "success", 5000);  // No await - instant display
+          
+          // Step 2: Play sound (after toast is triggered)
+          // Only play sound in sound-first, sound-only, or both mode
+          if (config.notificationMode !== 'tts-first') {
+            await playSound(config.idleSound, 1);
+          }
+          
+          // Step 3: Check race condition - did user respond during sound?
+          if (lastUserActivityTime > lastSessionIdleTime) {
+            debugLog(`session.idle: user active during sound - aborting`);
+            return;
+          }
+
+          // Step 4: Generate AI message for reminder AFTER sound played
+          const reminderMessage = await getSmartMessage('idle', true, config.idleReminderTTSMessages);
+
+          // Step 5: Schedule TTS reminder if enabled
+          if (config.enableTTSReminder && reminderMessage) {
+            scheduleTTSReminder('idle', reminderMessage, {
+              fallbackSound: config.idleSound
+            });
+          }
+          
+          // Step 6: If TTS-first or both mode, generate and speak immediate message
+          if (config.notificationMode === 'tts-first' || config.notificationMode === 'both') {
+            const ttsMessage = await getSmartMessage('idle', false, config.idleTTSMessages);
+            await tts.wakeMonitor();
+            await tts.forceVolume();
+            await tts.speak(ttsMessage, {
+              enableTTS: true,
+              fallbackSound: config.idleSound
+            });
+          }
         }
 
         // ========================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-smart-voice-notify",
-  "version": "1.1.2",
+  "version": "1.2.2",
   "description": "Smart voice notification plugin for OpenCode with multiple TTS engines (ElevenLabs, Edge TTS, Windows SAPI) and intelligent reminder system",
   "main": "index.js",
   "type": "module",

package/util/ai-messages.js

@@ -0,0 +1,205 @@
+/**
+ * AI Message Generation Module
+ * 
+ * Generates dynamic notification messages using OpenAI-compatible AI endpoints.
+ * Supports: Ollama, LM Studio, LocalAI, vLLM, llama.cpp, Jan.ai, etc.
+ * 
+ * Uses native fetch() - no external dependencies required.
+ */
+
+import { getTTSConfig } from './tts.js';
+
+/**
+ * Generate a message using an OpenAI-compatible AI endpoint
+ * @param {string} promptType - The type of prompt ('idle', 'permission', 'question', 'idleReminder', 'permissionReminder', 'questionReminder')
+ * @param {object} context - Optional context about the notification (for future use)
+ * @returns {Promise<string|null>} Generated message or null if failed
+ */
+export async function generateAIMessage(promptType, context = {}) {
+  const config = getTTSConfig();
+  
+  // Check if AI messages are enabled
+  if (!config.enableAIMessages) {
+    return null;
+  }
+  
+  // Get the prompt for this type
+  let prompt = config.aiPrompts?.[promptType];
+  if (!prompt) {
+    return null;
+  }
+  
+  // Inject count context if multiple items
+  if (context.count && context.count > 1) {
+    // Use type-specific terminology
+    let itemType = 'items';
+    if (context.type === 'question') {
+      itemType = 'questions';
+    } else if (context.type === 'permission') {
+      itemType = 'permission requests';
+    }
+    prompt = `${prompt} Important: There are ${context.count} ${itemType} (not just one) waiting for the user's attention. Mention the count in your message.`;
+  }
+  
+  try {
+    // Build headers
+    const headers = { 'Content-Type': 'application/json' };
+    if (config.aiApiKey) {
+      headers['Authorization'] = `Bearer ${config.aiApiKey}`;
+    }
+    
+    // Build endpoint URL (ensure it ends with /chat/completions)
+    let endpoint = config.aiEndpoint || 'http://localhost:11434/v1';
+    if (!endpoint.endsWith('/chat/completions')) {
+      endpoint = endpoint.replace(/\/$/, '') + '/chat/completions';
+    }
+    
+    // Create abort controller for timeout
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), config.aiTimeout || 15000);
+    
+    // Make the request
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify({
+        model: config.aiModel || 'llama3',
+        messages: [
+          {
+            role: 'system',
+            content: 'You are a helpful assistant that generates short notification messages. Output only the message text, nothing else. No quotes, no explanations.'
+          },
+          {
+            role: 'user',
+            content: prompt
+          }
+        ],
+        max_tokens: 1000,  // High value to accommodate thinking models (e.g., Gemini 2.5) that use internal reasoning tokens
+        temperature: 0.7
+      })
+    });
+    
+    clearTimeout(timeout);
+    
+    if (!response.ok) {
+      return null;
+    }
+    
+    const data = await response.json();
+    
+    // Extract the message content
+    const message = data.choices?.[0]?.message?.content?.trim();
+    
+    if (!message) {
+      return null;
+    }
+    
+    // Clean up the message (remove quotes if AI added them)
+    let cleanMessage = message.replace(/^["']|["']$/g, '').trim();
+    
+    // Validate message length (sanity check)
+    if (cleanMessage.length < 5 || cleanMessage.length > 200) {
+      return null;
+    }
+    
+    return cleanMessage;
+    
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get a smart message - tries AI first, falls back to static messages
+ * @param {string} eventType - 'idle', 'permission', 'question'
+ * @param {boolean} isReminder - Whether this is a reminder message
+ * @param {string[]} staticMessages - Array of static fallback messages
+ * @param {object} context - Optional context (e.g., { count: 3 } for batched notifications)
+ * @returns {Promise<string>} The message to speak
+ */
+export async function getSmartMessage(eventType, isReminder, staticMessages, context = {}) {
+  const config = getTTSConfig();
+  
+  // Determine the prompt type
+  const promptType = isReminder ? `${eventType}Reminder` : eventType;
+  
+  // Try AI generation if enabled
+  if (config.enableAIMessages) {
+    try {
+      const aiMessage = await generateAIMessage(promptType, context);
+      if (aiMessage) {
+        return aiMessage;
+      }
+    } catch (error) {
+      // Silently fall through to fallback
+    }
+    
+    // Check if fallback is disabled
+    if (!config.aiFallbackToStatic) {
+      // Return a generic message if fallback disabled and AI failed
+      return 'Notification: Please check your screen.';
+    }
+  }
+  
+  // Fallback to static messages
+  if (!Array.isArray(staticMessages) || staticMessages.length === 0) {
+    return 'Notification';
+  }
+  
+  return staticMessages[Math.floor(Math.random() * staticMessages.length)];
+}
+
+/**
+ * Test connectivity to the AI endpoint
+ * @returns {Promise<{success: boolean, message: string, model?: string}>}
+ */
+export async function testAIConnection() {
+  const config = getTTSConfig();
+  
+  if (!config.enableAIMessages) {
+    return { success: false, message: 'AI messages not enabled' };
+  }
+  
+  try {
+    const headers = { 'Content-Type': 'application/json' };
+    if (config.aiApiKey) {
+      headers['Authorization'] = `Bearer ${config.aiApiKey}`;
+    }
+    
+    // Try to list models (simpler endpoint to test connectivity)
+    let endpoint = config.aiEndpoint || 'http://localhost:11434/v1';
+    endpoint = endpoint.replace(/\/$/, '') + '/models';
+    
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers,
+      signal: controller.signal
+    });
+    
+    clearTimeout(timeout);
+    
+    if (response.ok) {
+      const data = await response.json();
+      const models = data.data?.map(m => m.id) || [];
+      return {
+        success: true,
+        message: `Connected! Available models: ${models.slice(0, 3).join(', ')}${models.length > 3 ? '...' : ''}`,
+        models
+      };
+    } else {
+      return { success: false, message: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return { success: false, message: 'Connection timed out' };
+    }
+    return { success: false, message: error.message };
+  }
+}
+
+export default { generateAIMessage, getSmartMessage, testAIConnection };

package/util/config.js

@@ -297,6 +297,54 @@ const generateDefaultConfig = (overrides = {}, version = '1.0.0') => {
     // Question batch window (ms) - how long to wait for more questions before notifying
     "questionBatchWindowMs": ${overrides.questionBatchWindowMs !== undefined ? overrides.questionBatchWindowMs : 800},
     
+    // ============================================================
+    // AI MESSAGE GENERATION (OpenAI-Compatible Endpoints)
+    // ============================================================
+    // Use a local/self-hosted AI to generate dynamic notification messages
+    // instead of using preset static messages. The AI generates the text,
+    // which is then spoken by your configured TTS engine (ElevenLabs, Edge, etc.)
+    //
+    // Supports: Ollama, LM Studio, LocalAI, vLLM, llama.cpp, Jan.ai, and any
+    // OpenAI-compatible endpoint. You provide your own endpoint URL and API key.
+    
+    // Enable AI-generated messages (experimental feature)
+    "enableAIMessages": ${overrides.enableAIMessages !== undefined ? overrides.enableAIMessages : false},
+    
+    // Your AI server endpoint URL (e.g., Ollama: http://localhost:11434/v1)
+    // Common endpoints:
+    //   Ollama:    http://localhost:11434/v1
+    //   LM Studio: http://localhost:1234/v1
+    //   LocalAI:   http://localhost:8080/v1
+    //   vLLM:      http://localhost:8000/v1
+    //   Jan.ai:    http://localhost:1337/v1
+    "aiEndpoint": "${overrides.aiEndpoint || 'http://localhost:11434/v1'}",
+    
+    // Model name to use (depends on what's loaded in your AI server)
+    // Examples: "llama3", "mistral", "phi3", "gemma2", "qwen2"
+    "aiModel": "${overrides.aiModel || 'llama3'}",
+    
+    // API key for your AI server (leave empty for Ollama/LM Studio/LocalAI)
+    // Only needed if your server requires authentication
+    "aiApiKey": "${overrides.aiApiKey || ''}",
+    
+    // Request timeout in milliseconds (local AI can be slow on first request)
+    "aiTimeout": ${overrides.aiTimeout !== undefined ? overrides.aiTimeout : 15000},
+    
+    // Fallback to static preset messages if AI generation fails
+    "aiFallbackToStatic": ${overrides.aiFallbackToStatic !== undefined ? overrides.aiFallbackToStatic : true},
+    
+    // Custom prompts for each notification type
+    // The AI will generate a short message based on these prompts
+    // Keep prompts concise - they're sent with each notification
+    "aiPrompts": ${formatJSON(overrides.aiPrompts || {
+        "idle": "Generate a single brief, friendly notification sentence (max 15 words) saying a coding task is complete. Be encouraging and warm. Output only the message, no quotes.",
+        "permission": "Generate a single brief, urgent but friendly notification sentence (max 15 words) asking the user to approve a permission request. Output only the message, no quotes.",
+        "question": "Generate a single brief, polite notification sentence (max 15 words) saying the assistant has a question and needs user input. Output only the message, no quotes.",
+        "idleReminder": "Generate a single brief, gentle reminder sentence (max 15 words) that a completed task is waiting for review. Be slightly more insistent. Output only the message, no quotes.",
+        "permissionReminder": "Generate a single brief, urgent reminder sentence (max 15 words) that permission approval is still needed. Convey importance. Output only the message, no quotes.",
+        "questionReminder": "Generate a single brief, polite but persistent reminder sentence (max 15 words) that a question is still waiting for an answer. Output only the message, no quotes."
+    }, 4)},
+    
     // ============================================================
     // SOUND FILES (For immediate notifications)
     // These are played first before TTS reminder kicks in