squidclaw 0.8.2 → 0.9.0

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

@@ -53,6 +53,17 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
       const fullResponse = result.messages.join('\n');
       const toolResult = await toolRouter.processResponse(fullResponse, agent.id);
 
+      if (toolResult.toolUsed && toolResult.toolName === 'remind' && toolResult.reminderTime) {
+        // Reminder requested — store it via engine's reminder manager
+        result._reminder = {
+          time: toolResult.reminderTime,
+          message: toolResult.reminderMessage,
+          contactId,
+        };
+        result.messages = ['Done! I will remind you at that time ⏰'];
+        return result;
+      }
+
       if (toolResult.toolUsed && (toolResult.imageBase64 || toolResult.imageUrl)) {
         // Image generated — pass through directly
         result.image = { base64: toolResult.imageBase64, url: toolResult.imageUrl, mimeType: toolResult.mimeType };

package/lib/engine.js

@@ -235,13 +235,25 @@ export class SquidclawEngine {
           }
           
           if (result.messages && result.messages.length > 0) {
+            // Handle reminder if requested
+            if (result._reminder && this.reminders) {
+              const { time, message: remMsg } = result._reminder;
+              this.reminders.add(agentId, contactId, remMsg, time, 'telegram', 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 {
-              // Send image if generated
+              // Handle reminder if requested
+            if (result._reminder && this.reminders) {
+              const { time, message: remMsg } = result._reminder;
+              this.reminders.add(agentId, contactId, remMsg, time, 'telegram', metadata);
+            }
+
+            // Send image if generated
             if (result.image) {
               await this.telegramManager.sendPhoto(agentId, contactId, result.image, result.messages?.[0] || '', metadata);
             } else {

package/lib/features/reminders.js

@@ -0,0 +1,144 @@
+/**
+ * 🦑 Reminders & Scheduled Messages
+ * Agent can set reminders and proactively message users at scheduled times
+ */
+
+import { logger } from '../core/logger.js';
+
+export class ReminderManager {
+  constructor(storage) {
+    this.storage = storage;
+    this.timers = new Map(); // id -> timeout
+    this.onFire = null; // callback(agentId, contactId, message, platform, metadata)
+    this._initDb();
+    this._loadPending();
+  }
+
+  _initDb() {
+    try {
+      this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS reminders (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          contact_id TEXT NOT NULL,
+          message TEXT NOT NULL,
+          fire_at TEXT NOT NULL,
+          platform TEXT DEFAULT 'telegram',
+          metadata TEXT DEFAULT '{}',
+          fired INTEGER DEFAULT 0,
+          created_at TEXT DEFAULT (datetime('now'))
+        )
+      `);
+    } catch (err) {
+      logger.error('reminders', 'Failed to init DB: ' + err.message);
+    }
+  }
+
+  _loadPending() {
+    try {
+      const rows = this.storage.db.prepare(
+        "SELECT * FROM reminders WHERE fired = 0 AND fire_at > datetime('now')"
+      ).all();
+      
+      for (const row of rows) {
+        this._schedule(row);
+      }
+      
+      if (rows.length > 0) {
+        logger.info('reminders', `Loaded ${rows.length} pending reminders`);
+      }
+    } catch (err) {
+      logger.error('reminders', 'Failed to load pending: ' + err.message);
+    }
+  }
+
+  _schedule(reminder) {
+    const fireAt = new Date(reminder.fire_at + 'Z');
+    const now = Date.now();
+    const delay = fireAt.getTime() - now;
+
+    if (delay <= 0) {
+      // Already past — fire immediately
+      this._fire(reminder);
+      return;
+    }
+
+    const timer = setTimeout(() => this._fire(reminder), delay);
+    this.timers.set(reminder.id, timer);
+  }
+
+  async _fire(reminder) {
+    logger.info('reminders', `Firing reminder ${reminder.id} for ${reminder.contact_id}`);
+    
+    // Mark as fired
+    try {
+      this.storage.db.prepare('UPDATE reminders SET fired = 1 WHERE id = ?').run(reminder.id);
+    } catch {}
+
+    this.timers.delete(reminder.id);
+
+    // Call the callback
+    if (this.onFire) {
+      const metadata = JSON.parse(reminder.metadata || '{}');
+      metadata.platform = reminder.platform;
+      await this.onFire(reminder.agent_id, reminder.contact_id, reminder.message, reminder.platform, metadata);
+    }
+  }
+
+  /**
+   * Add a reminder
+   * @param {string} agentId
+   * @param {string} contactId 
+   * @param {string} message - What to say when reminder fires
+   * @param {Date|string} fireAt - When to fire (UTC)
+   * @param {string} platform - telegram/whatsapp
+   * @param {object} metadata - chat metadata for sending
+   */
+  add(agentId, contactId, message, fireAt, platform = 'telegram', metadata = {}) {
+    const id = 'rem_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+    const fireAtStr = typeof fireAt === 'string' ? fireAt : fireAt.toISOString().replace('Z', '');
+
+    this.storage.db.prepare(
+      'INSERT INTO reminders (id, agent_id, contact_id, message, fire_at, platform, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    ).run(id, agentId, contactId, message, fireAtStr, platform, JSON.stringify(metadata));
+
+    this._schedule({ id, agent_id: agentId, contact_id: contactId, message, fire_at: fireAtStr, platform, metadata: JSON.stringify(metadata) });
+
+    logger.info('reminders', `Reminder ${id} set for ${fireAtStr}`);
+    return id;
+  }
+
+  /**
+   * List pending reminders for a contact
+   */
+  list(agentId, contactId) {
+    return this.storage.db.prepare(
+      "SELECT * FROM reminders WHERE agent_id = ? AND contact_id = ? AND fired = 0 AND fire_at > datetime('now') ORDER BY fire_at"
+    ).all(agentId, contactId);
+  }
+
+  /**
+   * Cancel a reminder
+   */
+  cancel(id) {
+    const timer = this.timers.get(id);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(id);
+    this.storage.db.prepare('UPDATE reminders SET fired = 1 WHERE id = ?').run(id);
+    return true;
+  }
+
+  /**
+   * Cancel all reminders for a contact
+   */
+  cancelAll(agentId, contactId) {
+    const pending = this.list(agentId, contactId);
+    for (const r of pending) this.cancel(r.id);
+    return pending.length;
+  }
+
+  destroy() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+  }
+}

package/lib/tools/image-gen.js

@@ -1,6 +1,6 @@
 /**
  * 🦑 Image Generation Tool
- * Supports: OpenAI DALL-E, Google Gemini/Imagen
+ * Supports: OpenAI DALL-E 3, Google Gemini Flash Image
  */
 
 import { logger } from '../core/logger.js';
@@ -13,13 +13,14 @@ export class ImageGenTool {
   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');
     }
 
+    logger.info('image-gen', `Generating with ${provider}: ${prompt.slice(0, 80)}...`);
+
     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);
@@ -37,52 +38,30 @@ export class ImageGenTool {
   }
 
   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}`, {
+    // Try gemini-2.5-flash-image (native image generation)
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-image:generateContent?key=${apiKey}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        instances: [{ prompt }],
-        parameters: { sampleCount: 1, aspectRatio: '1:1' },
+        contents: [{ parts: [{ text: `Generate an image: ${prompt}` }] }],
+        generationConfig: { responseModalities: ['TEXT', 'IMAGE'] },
       }),
     });
     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' };
+    if (data.error) {
+      logger.error('image-gen', `Gemini error: ${data.error.message}`);
+      throw new Error(data.error.message);
     }
 
-    // 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) {
+        logger.info('image-gen', `Image generated! ${part.inlineData.mimeType}, ${part.inlineData.data?.length} bytes`);
         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

@@ -59,6 +59,12 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    tools.push('', '### Set Reminder',
+      '---TOOL:remind:YYYY-MM-DDTHH:MM|Your reminder message---',
+      'Set a reminder to message the user at a specific time. Time must be in UTC.',
+      'Example: ---TOOL:remind:2026-03-03T08:30|Wake up! Time to start the day!---',
+      'The user will receive a proactive message at that time even if they are not chatting.');
+
     tools.push('', '**Important:** Use tools when needed. The tool result will be injected into the conversation automatically. Only use one tool per response.');
 
     return tools.join('\n');
@@ -85,23 +91,41 @@ export class ToolRouter {
           toolResult = results.map(r => `• ${r.title}\n  ${r.snippet}\n  ${r.url}`).join('\n\n');
           break;
 
+        case 'remind':
+        case 'reminder': {
+          try {
+            const pipeIdx = toolArg.indexOf('|');
+            if (pipeIdx === -1) {
+              toolResult = 'Invalid reminder format. Use: YYYY-MM-DDTHH:MM|message';
+              break;
+            }
+            const timeStr = toolArg.slice(0, pipeIdx).trim();
+            const msg = toolArg.slice(pipeIdx + 1).trim();
+            // Store reminder request in result for engine to pick up
+            return { toolUsed: true, toolName: 'remind', reminderTime: timeStr, reminderMessage: msg, cleanResponse };
+          } catch (err) {
+            toolResult = 'Failed to set reminder: ' + err.message;
+          }
+          break;
+        }
         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 };
+        case 'draw':
+        case 'image': {
+          try {
+            const { ImageGenTool } = await import('./image-gen.js');
+            const gen = new ImageGenTool(this.config);
+            const imgResult = await gen.generate(toolArg);
+            if (imgResult.url) {
+              return { toolUsed: true, toolName: 'image', toolResult: imgResult.url, imageUrl: imgResult.url, cleanResponse };
+            } else if (imgResult.base64) {
+              return { toolUsed: true, toolName: 'image', toolResult: '[Image generated]', imageBase64: imgResult.base64, mimeType: imgResult.mimeType, cleanResponse };
+            }
+          } catch (err) {
+            toolResult = 'Image generation failed: ' + err.message;
           }
-        } catch (err) {
-          return { toolUsed: true, toolName: 'image', toolResult: 'Image generation failed: ' + err.message };
+          break;
         }
-      }
-      case 'read':
+        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.8.2",
+  "version": "0.9.0",
   "description": "\ud83e\udd91 AI agent platform \u2014 human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {