squidclaw 0.7.0 → 0.7.2

package/lib/channels/hub.js

@@ -43,6 +43,17 @@ export class ChannelHub {
       return;
     }
 
+    // Handle API key detection
+    const { detectApiKey, saveApiKey, getKeyConfirmation, detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('../features/self-config.js');
+    
+    const keyDetected = detectApiKey(message);
+    if (keyDetected && keyDetected.provider !== 'unknown') {
+      saveApiKey(keyDetected.provider, keyDetected.key);
+      const confirmation = getKeyConfirmation(keyDetected.provider);
+      await this.whatsappManager.sendMessage(agentId, contactId, confirmation);
+      return;
+    }
+
     // Handle /help
     if (message.trim() === '/help') {
       const helpText = [
@@ -69,7 +80,7 @@ export class ChannelHub {
         await AgentBackup.saveToFile(backup, home + '/backups/' + filename);
         const size = (JSON.stringify(backup).length / 1024).toFixed(1);
         await this.whatsappManager.sendMessage(agentId, contactId, 
-          '💾 *Backup Complete!*\n\n📦 ' + filename + '\n📏 ' + size + ' KB\n💬 ' + (backup.conversations?.length || 0) + ' messages\n🧠 ' + (backup.memories?.length || 0) + ' memories\n\nI\'m safe! 🦑');
+          '💾 *Backup Complete!*\n\n📦 ' + filename + '\n📏 ' + size + ' KB\n💬 ' + (backup.conversations?.length || 0) + ' messages\n🧠 ' + (backup.memories?.length || 0) + ' memories\n\nI am safe! 🦑');
       } catch (err) {
         await this.whatsappManager.sendMessage(agentId, contactId, '❌ Backup failed: ' + err.message);
       }
@@ -125,6 +136,20 @@ export class ChannelHub {
       return;
     }
 
+    // Check if asking for unavailable skill
+    const skillRequest = detectSkillRequest(message);
+    if (skillRequest) {
+      const config = (await import('../core/config.js')).loadConfig();
+      const availability = checkSkillAvailable(skillRequest, config);
+      if (!availability.available) {
+        const keyMsg = getKeyRequestMessage(skillRequest);
+        if (keyMsg) {
+          await this.whatsappManager.sendMessage(agentId, contactId, keyMsg);
+          return;
+        }
+      }
+    }
+
     // Process message through agent
     const result = await agent.processMessage(contactId, message, metadata);
 

package/lib/engine.js

@@ -93,6 +93,17 @@ export class SquidclawEngine {
             if (!allowed) return;
           }
 
+          // Handle API key detection — user pasting a key
+          const { detectApiKey, saveApiKey, getKeyConfirmation, detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('./features/self-config.js');
+          
+          const keyDetected = detectApiKey(message);
+          if (keyDetected && keyDetected.provider !== 'unknown') {
+            saveApiKey(keyDetected.provider, keyDetected.key);
+            const confirmation = getKeyConfirmation(keyDetected.provider);
+            await this.telegramManager.sendMessage(agentId, contactId, confirmation, metadata);
+            return;
+          }
+
           // Handle /help command
           if (message.trim() === '/help') {
             const helpText = [
@@ -130,7 +141,7 @@ export class SquidclawEngine {
                   '🧠 Memories: ' + (backup.memories?.length || 0),
                   '📄 Files: ' + Object.keys(backup.files).length,
                   '',
-                  'I\'m safe! You can resurrect me anytime with this file 🦑',
+                  'I am safe! You can resurrect me anytime with this file 🦑',
                 ];
                 await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
               } catch (err) {
@@ -186,6 +197,19 @@ export class SquidclawEngine {
             return;
           }
 
+          // Check if user is asking for a skill we don't have
+          const skillRequest = detectSkillRequest(message);
+          if (skillRequest) {
+            const availability = checkSkillAvailable(skillRequest, this.config);
+            if (!availability.available) {
+              const keyMsg = getKeyRequestMessage(skillRequest);
+              if (keyMsg) {
+                await this.telegramManager.sendMessage(agentId, contactId, keyMsg, metadata);
+                return;
+              }
+            }
+          }
+
           const result = await agent.processMessage(contactId, message, metadata);
           
           if (result.reaction && metadata.messageId) {

package/lib/features/self-config.js

@@ -0,0 +1,204 @@
+/**
+ * 🦑 Self-Configuration
+ * Agent can request and add API keys through chat
+ */
+
+import { loadConfig, saveConfig } from '../core/config.js';
+import { logger } from '../core/logger.js';
+
+// Skills that need specific API keys
+const SKILL_REQUIREMENTS = {
+  'image_generation': {
+    name: 'Image Generation',
+    providers: [
+      { id: 'openai', label: 'OpenAI (DALL-E)', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+      { id: 'google', label: 'Google (Gemini/Imagen)', keyUrl: 'aistudio.google.dev/apikey', keyPrefix: 'AI' },
+    ],
+  },
+  'vision': {
+    name: 'Image Understanding',
+    providers: [
+      { id: 'anthropic', label: 'Anthropic (Claude Vision)', keyUrl: 'console.anthropic.com/keys', keyPrefix: 'sk-ant-' },
+      { id: 'openai', label: 'OpenAI (GPT-4 Vision)', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'voice_tts': {
+    name: 'Voice Notes (TTS)',
+    providers: [
+      { id: 'edge', label: 'Microsoft Edge TTS (FREE)', keyPrefix: null },
+      { id: 'openai', label: 'OpenAI TTS', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'transcription': {
+    name: 'Voice Transcription',
+    providers: [
+      { id: 'groq', label: 'Groq Whisper (FREE)', keyUrl: 'console.groq.com/keys', keyPrefix: 'gsk_' },
+      { id: 'openai', label: 'OpenAI Whisper', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'web_search': {
+    name: 'Web Search',
+    providers: [
+      { id: 'duckduckgo', label: 'DuckDuckGo (FREE)', keyPrefix: null },
+    ],
+  },
+  'code_execution': {
+    name: 'Code Execution',
+    providers: [
+      { id: 'local', label: 'Local (sandboxed)', keyPrefix: null },
+    ],
+  },
+};
+
+// Detect what skill the user is asking for
+export function detectSkillRequest(message) {
+  const lower = message.toLowerCase();
+  
+  if (lower.match(/generat.*image|create.*image|draw|make.*picture|dall.?e|imagen|image.*generat/)) {
+    return 'image_generation';
+  }
+  if (lower.match(/analyz.*image|understand.*image|what.*this.*photo|vision|see.*image|look.*at/)) {
+    return 'vision';
+  }
+  if (lower.match(/voice.*note|speak|tts|text.*to.*speech|send.*voice/)) {
+    return 'voice_tts';
+  }
+  if (lower.match(/transcrib|speech.*to.*text|whisper/)) {
+    return 'transcription';
+  }
+  if (lower.match(/run.*code|execut.*code|python|javascript/)) {
+    return 'code_execution';
+  }
+  return null;
+}
+
+// Check if we have the key for a skill
+export function checkSkillAvailable(skill, config) {
+  const req = SKILL_REQUIREMENTS[skill];
+  if (!req) return { available: true };
+
+  for (const prov of req.providers) {
+    if (!prov.keyPrefix) return { available: true, provider: prov }; // Free skill
+    const key = config.ai?.providers?.[prov.id]?.key;
+    if (key && key !== 'local' && key.length > 5) {
+      return { available: true, provider: prov };
+    }
+  }
+
+  return { available: false, skill: req, requirements: req.providers.filter(p => p.keyPrefix) };
+}
+
+// Generate "I need a key" message
+export function getKeyRequestMessage(skill) {
+  const req = SKILL_REQUIREMENTS[skill];
+  if (!req) return null;
+
+  const providers = req.providers.filter(p => p.keyPrefix);
+  if (providers.length === 0) return null;
+
+  const lines = [
+    `🔑 I need an API key to ${req.name.toLowerCase()}!`,
+    '',
+  ];
+
+  for (const prov of providers) {
+    lines.push(`*${prov.label}*`);
+    lines.push(`Get yours at: ${prov.keyUrl}`);
+    lines.push('');
+  }
+
+  lines.push('Just paste the key here and I will add it myself! 🦑');
+
+  return lines.join('\n');
+}
+
+// Detect if a message contains an API key
+export function detectApiKey(message) {
+  const trimmed = message.trim();
+  
+  // Split by whitespace and newlines — check each token
+  const tokens = trimmed.split(/[\s\n]+/);
+  
+  for (const token of tokens) {
+    const t = token.trim();
+    if (t.length < 10) continue;
+    
+    // Anthropic
+    if (t.startsWith('sk-ant-')) {
+      return { provider: 'anthropic', key: t };
+    }
+    // OpenAI
+    if (t.startsWith('sk-') && !t.startsWith('sk-ant-') && t.length > 20) {
+      return { provider: 'openai', key: t };
+    }
+    // Groq
+    if (t.startsWith('gsk_') && t.length > 15) {
+      return { provider: 'groq', key: t };
+    }
+    // Google (AIza...)
+    if (t.startsWith('AIza') && t.length > 20) {
+      return { provider: 'google', key: t };
+    }
+  }
+
+  // Check full message for long unbroken tokens (generic key)
+  for (const token of tokens) {
+    if (token.length > 30 && !/\s/.test(token) && /^[A-Za-z0-9_\-]+$/.test(token)) {
+      return { provider: 'unknown', key: token };
+    }
+  }
+
+  return null;
+}
+
+// Save an API key to config
+export function saveApiKey(provider, key) {
+  const config = loadConfig();
+  config.ai = config.ai || { providers: {} };
+  config.ai.providers = config.ai.providers || {};
+  config.ai.providers[provider] = config.ai.providers[provider] || {};
+  config.ai.providers[provider].key = key;
+  saveConfig(config);
+  
+  logger.info('self-config', `API key saved for provider: ${provider}`);
+  return true;
+}
+
+// Get confirmation message after key is saved
+export function getKeyConfirmation(provider) {
+  const providerNames = {
+    anthropic: 'Anthropic (Claude)',
+    openai: 'OpenAI',
+    google: 'Google (Gemini)',
+    groq: 'Groq',
+    together: 'Together AI',
+    cerebras: 'Cerebras',
+    mistral: 'Mistral',
+  };
+
+  const skills = {
+    anthropic: ['Chat (Claude)', 'Image Understanding', 'Code Analysis'],
+    openai: ['Chat (GPT-4o)', 'Image Generation (DALL-E)', 'Voice (Whisper + TTS)', 'Image Understanding'],
+    google: ['Chat (Gemini)', 'Image Generation (Imagen)', 'Embeddings'],
+    groq: ['Chat (Llama)', 'Voice Transcription (Whisper) — FREE'],
+    together: ['Chat (Llama, DeepSeek)'],
+    cerebras: ['Chat (Llama) — FREE'],
+    mistral: ['Chat (Mistral)'],
+  };
+
+  const name = providerNames[provider] || provider;
+  const newSkills = skills[provider] || ['Chat'];
+
+  const lines = [
+    `✅ *${name} key added!*`,
+    '',
+    '🆕 New skills unlocked:',
+    ...newSkills.map(s => `  • ${s}`),
+    '',
+    'I am now more powerful! Try asking me to use these 🦑',
+  ];
+
+  return lines.join('\n');
+}
+
+export { SKILL_REQUIREMENTS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "\ud83e\udd91 AI agent platform \u2014 human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {