squidclaw 0.7.1 → 0.8.0

package/lib/channels/telegram/bot.js

@@ -166,6 +166,26 @@ export class TelegramManager {
     } catch {} // Reactions might not be supported in all chats
   }
 
+  async sendPhoto(agentId, contactId, photoData, caption, metadata = {}) {
+    const chatId = metadata.chatId || contactId;
+    const token = metadata.token;
+    const botInfo = this.bots.get(token);
+    if (!botInfo) return;
+
+    try {
+      if (photoData.url) {
+        await botInfo.bot.api.sendPhoto(chatId, photoData.url, { caption });
+      } else if (photoData.base64) {
+        const buffer = Buffer.from(photoData.base64, 'base64');
+        const { InputFile } = await import('grammy');
+        await botInfo.bot.api.sendPhoto(chatId, new InputFile(buffer, 'image.png'), { caption });
+      }
+    } catch (err) {
+      logger.error('telegram', 'Failed to send photo:', err.message);
+      if (caption) await this.sendMessage(agentId, contactId, caption, metadata);
+    }
+  }
+
   /**
    * Send voice note
    */

package/lib/core/agent-tools-mixin.js

@@ -53,6 +53,13 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
       const fullResponse = result.messages.join('\n');
       const toolResult = await toolRouter.processResponse(fullResponse, agent.id);
 
+      if (toolResult.toolUsed && (toolResult.imageBase64 || toolResult.imageUrl)) {
+        // Image generated — pass through directly
+        result.image = { base64: toolResult.imageBase64, url: toolResult.imageUrl, mimeType: toolResult.mimeType };
+        result.messages = ['Here you go! 🎨'];
+        return result;
+      }
+
       if (toolResult.toolUsed && toolResult.toolResult) {
         // Agent used a tool — now call AI again with the tool result
         logger.info('agent', `Tool ${toolResult.toolName} returned, calling AI again...`);

package/lib/engine.js

@@ -99,6 +99,9 @@ export class SquidclawEngine {
           const keyDetected = detectApiKey(message);
           if (keyDetected && keyDetected.provider !== 'unknown') {
             saveApiKey(keyDetected.provider, keyDetected.key);
+            // Reload config so skills see the new key
+            const { loadConfig } = await import('./core/config.js');
+            this.config = loadConfig();
             const confirmation = getKeyConfirmation(keyDetected.provider);
             await this.telegramManager.sendMessage(agentId, contactId, confirmation, metadata);
             return;
@@ -217,7 +220,14 @@ export class SquidclawEngine {
           }
           
           if (result.messages && result.messages.length > 0) {
-            await this.telegramManager.sendMessages(agentId, contactId, result.messages, metadata);
+            // Send image if generated
+            if (result.image) {
+              const photoData = result.image.url ? { url: result.image.url } : { base64: result.image.base64 };
+              const caption = result.messages?.[0] || '';
+              await this.telegramManager.sendPhoto(agentId, contactId, photoData, caption, metadata);
+            } else {
+              await this.telegramManager.sendMessages(agentId, contactId, result.messages, metadata);
+            }
           }
         };
 

package/lib/features/self-config.js

@@ -77,6 +77,7 @@ export function checkSkillAvailable(skill, config) {
   const req = SKILL_REQUIREMENTS[skill];
   if (!req) return { available: true };
 
+  // Check if ANY provider has a key that could handle this skill
   for (const prov of req.providers) {
     if (!prov.keyPrefix) return { available: true, provider: prov }; // Free skill
     const key = config.ai?.providers?.[prov.id]?.key;
@@ -84,6 +85,13 @@ export function checkSkillAvailable(skill, config) {
       return { available: true, provider: prov };
     }
   }
+  
+  // Special: image_generation works with google OR openai key
+  if (skill === 'image_generation') {
+    const googleKey = config.ai?.providers?.google?.key;
+    const openaiKey = config.ai?.providers?.openai?.key;
+    if (googleKey || openaiKey) return { available: true };
+  }
 
   return { available: false, skill: req, requirements: req.providers.filter(p => p.keyPrefix) };
 }
@@ -112,33 +120,40 @@ export function getKeyRequestMessage(skill) {
   return lines.join('\n');
 }
 
-// Detect if a message is an API key
+// Detect if a message contains an API key
 export function detectApiKey(message) {
   const trimmed = message.trim();
   
-  // Anthropic
-  if (trimmed.startsWith('sk-ant-')) {
-    return { provider: 'anthropic', key: trimmed };
-  }
-  // OpenAI
-  if (trimmed.startsWith('sk-') && !trimmed.startsWith('sk-ant-') && trimmed.length > 20) {
-    return { provider: 'openai', key: trimmed };
-  }
-  // Groq
-  if (trimmed.startsWith('gsk_')) {
-    return { provider: 'groq', key: trimmed };
-  }
-  // Google
-  if (trimmed.startsWith('AI') && trimmed.length > 20 && !trimmed.includes(' ')) {
-    return { provider: 'google', key: trimmed };
-  }
-  // Together
-  if (trimmed.length > 40 && !trimmed.includes(' ') && /^[a-f0-9]+$/.test(trimmed)) {
-    return { provider: 'together', key: trimmed };
+  // 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 };
+    }
   }
-  // Generic long token
-  if (trimmed.length > 30 && !trimmed.includes(' ') && !trimmed.includes('\n')) {
-    return { provider: 'unknown', key: trimmed };
+
+  // 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;

package/lib/tools/image-gen.js

@@ -0,0 +1,89 @@
+/**
+ * 🦑 Image Generation Tool
+ * Supports: OpenAI DALL-E, Google Gemini/Imagen
+ */
+
+import { logger } from '../core/logger.js';
+
+export class ImageGenTool {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async generate(prompt, provider) {
+    const providers = this.config.ai?.providers || {};
+
+    // Auto-select provider
+    if (!provider) {
+      if (providers.openai?.key) provider = 'openai';
+      else if (providers.google?.key) provider = 'google';
+      else throw new Error('No image generation API key configured');
+    }
+
+    if (provider === 'openai') return this.generateOpenAI(prompt, providers.openai.key);
+    if (provider === 'google') return this.generateGemini(prompt, providers.google.key);
+    throw new Error('Unsupported provider: ' + provider);
+  }
+
+  async generateOpenAI(prompt, apiKey) {
+    const res = await fetch('https://api.openai.com/v1/images/generations', {
+      method: 'POST',
+      headers: { 'Authorization': 'Bearer ' + apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: 'dall-e-3', prompt, n: 1, size: '1024x1024' }),
+    });
+    const data = await res.json();
+    if (data.error) throw new Error(data.error.message);
+    return { url: data.data[0].url, revised_prompt: data.data[0].revised_prompt };
+  }
+
+  async generateGemini(prompt, apiKey) {
+    // Gemini Imagen 3 via generateImages endpoint
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/imagen-3.0-generate-002:predict?key=${apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        instances: [{ prompt }],
+        parameters: { sampleCount: 1, aspectRatio: '1:1' },
+      }),
+    });
+    const data = await res.json();
+    
+    if (data.error) {
+      // Fallback: use Gemini 2.0 Flash native image generation
+      return this.generateGeminiFlash(prompt, apiKey);
+    }
+
+    if (data.predictions?.[0]?.bytesBase64Encoded) {
+      return { base64: data.predictions[0].bytesBase64Encoded, mimeType: 'image/png' };
+    }
+
+    // Fallback to Gemini Flash
+    return this.generateGeminiFlash(prompt, apiKey);
+  }
+
+  async generateGeminiFlash(prompt, apiKey) {
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent?key=${apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: `Generate an image: ${prompt}` }] }],
+        generationConfig: { responseModalities: ['TEXT', 'IMAGE'] },
+      }),
+    });
+    const data = await res.json();
+    
+    if (data.error) throw new Error(data.error.message);
+    
+    // Find image part in response
+    const parts = data.candidates?.[0]?.content?.parts || [];
+    for (const part of parts) {
+      if (part.inlineData) {
+        return { base64: part.inlineData.data, mimeType: part.inlineData.mimeType || 'image/png' };
+      }
+    }
+
+    // Text-only response
+    const text = parts.find(p => p.text)?.text;
+    throw new Error(text || 'Gemini could not generate an image');
+  }
+}

package/lib/tools/router.js

@@ -38,6 +38,13 @@ export class ToolRouter {
       'Search the agent\'s uploaded knowledge base for relevant information.',
     ];
 
+    // Image generation (if key available)
+    if (this.config.ai?.providers?.openai?.key || this.config.ai?.providers?.google?.key) {
+      tools.push('', '### Image Generation',
+        '---TOOL:imagine:detailed description of the image to generate---',
+        'Generate an image from a text description. Be detailed in your description for best results.');
+    }
+
     if (this.calendar) {
       tools.push('', '### Calendar', '---TOOL:calendar:today--- or ---TOOL:calendar:week---',
         'Check upcoming calendar events.');
@@ -78,7 +85,23 @@ export class ToolRouter {
           toolResult = results.map(r => `• ${r.title}\n  ${r.snippet}\n  ${r.url}`).join('\n\n');
           break;
 
-        case 'read':
+        case 'imagine':
+      case 'draw':
+      case 'image': {
+        try {
+          const { ImageGenTool } = await import('./image-gen.js');
+          const gen = new ImageGenTool(this.config);
+          const result = await gen.generate(args);
+          if (result.url) {
+            return { toolUsed: true, toolName: 'image', toolResult: result.url, imageUrl: result.url };
+          } else if (result.base64) {
+            return { toolUsed: true, toolName: 'image', toolResult: '[Image generated]', imageBase64: result.base64, mimeType: result.mimeType };
+          }
+        } catch (err) {
+          return { toolUsed: true, toolName: 'image', toolResult: 'Image generation failed: ' + err.message };
+        }
+      }
+      case 'read':
           const page = await this.browser.readPage(toolArg, 3000);
           toolResult = `Title: ${page.title}\n\n${page.content}`;
           break;

package/package.json

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