opencode-smart-voice-notify 1.1.2 → 1.2.0

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();
@@ -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,18 +408,19 @@ 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 (count === 1) {
-      // Single permission - use regular message
-      return getRandomMessage(messages);
+      // Single permission - use smart message (AI or static fallback)
+      return await getSmartMessage('permission', isReminder, messages, { count });
     } else {
       // Multiple permissions - use count-aware messages if available, or format dynamically
       const countMessages = isReminder
@@ -430,7 +432,11 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
         const template = getRandomMessage(countMessages);
         return template.replace('{count}', count.toString());
       } else {
-        // Fallback: generate a dynamic message
+        // Try AI message with count context, fallback to dynamic message
+        const aiMessage = await getSmartMessage('permission', isReminder, [], { count });
+        if (aiMessage !== 'Notification') {
+          return aiMessage;
+        }
         return `Attention! There are ${count} permission requests waiting for your approval.`;
       }
     }
@@ -438,18 +444,19 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
 
   /**
    * 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 (count === 1) {
-      // Single question - use regular message
-      return getRandomMessage(messages);
+      // Single question - use smart message (AI or static fallback)
+      return await getSmartMessage('question', isReminder, messages, { count });
     } else {
       // Multiple questions - use count-aware messages if available, or format dynamically
       const countMessages = isReminder
@@ -461,7 +468,11 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
         const template = getRandomMessage(countMessages);
         return template.replace('{count}', count.toString());
       } else {
-        // Fallback: generate a dynamic message
+        // Try AI message with count context, fallback to dynamic message
+        const aiMessage = await getSmartMessage('question', isReminder, [], { count });
+        if (aiMessage !== 'Notification') {
+          return aiMessage;
+        }
         return `Hey! I have ${count} questions for you. Please check your screen.`;
       }
     }
@@ -508,8 +519,8 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
     }
 
     // Get count-aware TTS message
-    const ttsMessage = getPermissionMessage(batchCount, false);
-    const reminderMessage = getPermissionMessage(batchCount, true);
+    const ttsMessage = await getPermissionMessage(batchCount, false);
+    const reminderMessage = await getPermissionMessage(batchCount, true);
 
     // Smart notification: sound first, TTS reminder later
     await smartNotify('permission', {
@@ -582,8 +593,8 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
     }
 
     // Get count-aware TTS message (uses total question count, not request count)
-    const ttsMessage = getQuestionMessage(totalQuestionCount, false);
-    const reminderMessage = getQuestionMessage(totalQuestionCount, true);
+    const ttsMessage = await getQuestionMessage(totalQuestionCount, false);
+    const reminderMessage = await getQuestionMessage(totalQuestionCount, true);
 
     // Smart notification: sound first, TTS reminder later
     // Sound plays 2 times by default (matching permission behavior)
@@ -755,11 +766,14 @@ export default async function SmartVoiceNotifyPlugin({ project, client, $, direc
           debugLog(`session.idle: notifying for session ${sessionID} (idleTime=${lastSessionIdleTime})`);
           await showToast("✅ Agent has finished working", "success", 5000);
 
+          // Get smart message for idle notification (AI or static fallback)
+          const idleTtsMessage = await getSmartMessage('idle', false, config.idleTTSMessages);
+
           // Smart notification: sound first, TTS reminder later
           await smartNotify('idle', {
             soundFile: config.idleSound,
             soundLoops: 1,
-            ttsMessage: getRandomMessage(config.idleTTSMessages),
+            ttsMessage: idleTtsMessage,
             fallbackSound: config.idleSound
           });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-smart-voice-notify",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "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,207 @@
+/**
+ * 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
+  const prompt = config.aiPrompts?.[promptType];
+  if (!prompt) {
+    console.error(`[AI Messages] No prompt configured for type: ${promptType}`);
+    return null;
+  }
+  
+  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) {
+      const errorText = await response.text().catch(() => 'Unknown error');
+      console.error(`[AI Messages] API error ${response.status}: ${errorText}`);
+      return null;
+    }
+    
+    const data = await response.json();
+    
+    // Extract the message content
+    const message = data.choices?.[0]?.message?.content?.trim();
+    
+    if (!message) {
+      console.error('[AI Messages] Empty response from AI');
+      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) {
+      console.error(`[AI Messages] Message length invalid: ${cleanMessage.length} chars`);
+      return null;
+    }
+    
+    return cleanMessage;
+    
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.error(`[AI Messages] Request timed out after ${config.aiTimeout || 15000}ms`);
+    } else {
+      console.error(`[AI Messages] Error: ${error.message}`);
+    }
+    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) {
+        // Log success for debugging
+        if (config.debugLog) {
+          console.log(`[AI Messages] Generated: ${aiMessage}`);
+        }
+        return aiMessage;
+      }
+    } catch (error) {
+      console.error(`[AI Messages] Generation failed: ${error.message}`);
+    }
+    
+    // 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