squidclaw 2.4.0 → 2.5.0

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

@@ -73,8 +73,9 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
         return result;
       }
 
-      // File attachment (pptx, etc)
+      // File attachment (pptx, excel, pdf, html)
       if (toolResult.toolUsed && toolResult.filePath) {
+        logger.info('agent', 'FILE TOOL: ' + toolResult.toolName + ' -> ' + toolResult.filePath);
         result.filePath = toolResult.filePath;
         result.fileName = toolResult.fileName;
         result.messages = [toolResult.toolResult || 'Here\'s your file! 📎'];

package/lib/engine.js

@@ -226,6 +226,12 @@ export class SquidclawEngine {
       if (pending.c > 0) console.log(`  ⏰ Reminders: ${pending.c} pending`);
     } catch {}
 
+    // Sessions
+    try {
+      const { SessionManager } = await import('./features/sessions.js');
+      this.sessions = new SessionManager(this.storage, this);
+    } catch (err) { logger.error('engine', 'Sessions init failed: ' + err.message); }
+
     // Cron jobs
     try {
       const { CronManager } = await import('./features/cron.js');

package/lib/features/sessions.js

@@ -0,0 +1,269 @@
+/**
+ * 🦑 Session Manager
+ * Multiple isolated conversations per agent
+ * Types: main (default), isolated (fresh context), thread (linked to parent)
+ */
+
+import { logger } from '../core/logger.js';
+import crypto from 'crypto';
+
+export class SessionManager {
+  constructor(storage, engine) {
+    this.storage = storage;
+    this.engine = engine;
+    this.active = new Map(); // sessionKey -> session
+    this._initDb();
+  }
+
+  _initDb() {
+    this.storage.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        type TEXT DEFAULT 'main',
+        label TEXT,
+        parent_id TEXT,
+        model TEXT,
+        system_prompt TEXT,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        metadata TEXT DEFAULT '{}'
+      );
+      CREATE TABLE IF NOT EXISTS session_messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tokens INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (session_id) REFERENCES sessions(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_messages_sid ON session_messages(session_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id, contact_id);
+    `);
+  }
+
+  // ── Session CRUD ──
+
+  create(agentId, contactId, options = {}) {
+    const id = 'sess_' + crypto.randomBytes(6).toString('hex');
+    const type = options.type || 'main';
+    const label = options.label || null;
+    const parentId = options.parentId || null;
+    const model = options.model || null;
+    const systemPrompt = options.systemPrompt || null;
+
+    this.storage.db.prepare(
+      'INSERT INTO sessions (id, agent_id, contact_id, type, label, parent_id, model, system_prompt, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
+    ).run(id, agentId, contactId, type, label, parentId, model, systemPrompt, JSON.stringify(options.metadata || {}));
+
+    const session = { id, agentId, contactId, type, label, parentId, model, systemPrompt, status: 'active' };
+    this.active.set(id, session);
+
+    logger.info('sessions', `Created ${type} session ${id}${label ? ' [' + label + ']' : ''}`);
+    return session;
+  }
+
+  get(sessionId) {
+    const cached = this.active.get(sessionId);
+    if (cached) return cached;
+
+    const row = this.storage.db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
+    if (row) {
+      this.active.set(row.id, row);
+      return row;
+    }
+    return null;
+  }
+
+  /**
+   * Get or create main session for a contact
+   */
+  getMain(agentId, contactId) {
+    let session = this.storage.db.prepare(
+      "SELECT * FROM sessions WHERE agent_id = ? AND contact_id = ? AND type = 'main' AND status = 'active' LIMIT 1"
+    ).get(agentId, contactId);
+
+    if (!session) {
+      session = this.create(agentId, contactId, { type: 'main', label: 'Main' });
+    }
+    return session;
+  }
+
+  /**
+   * Spawn an isolated session
+   */
+  spawn(agentId, contactId, options = {}) {
+    return this.create(agentId, contactId, {
+      type: options.type || 'isolated',
+      label: options.label || options.task?.slice(0, 50),
+      parentId: options.parentId,
+      model: options.model,
+      systemPrompt: options.systemPrompt || (options.task ? 
+        'You are a focused sub-agent. Complete this task concisely:\n\n' + options.task : null),
+      metadata: { task: options.task, timeout: options.timeout },
+    });
+  }
+
+  /**
+   * List sessions for a contact
+   */
+  list(agentId, contactId, options = {}) {
+    let query = 'SELECT * FROM sessions WHERE agent_id = ?';
+    const params = [agentId];
+
+    if (contactId) {
+      query += ' AND contact_id = ?';
+      params.push(contactId);
+    }
+    if (options.type) {
+      query += ' AND type = ?';
+      params.push(options.type);
+    }
+    if (options.status || !options.includeEnded) {
+      query += ' AND status = ?';
+      params.push(options.status || 'active');
+    }
+
+    query += ' ORDER BY created_at DESC';
+    if (options.limit) {
+      query += ' LIMIT ?';
+      params.push(options.limit);
+    }
+
+    return this.storage.db.prepare(query).all(...params);
+  }
+
+  /**
+   * End a session
+   */
+  end(sessionId) {
+    this.storage.db.prepare("UPDATE sessions SET status = 'ended', updated_at = datetime('now') WHERE id = ?").run(sessionId);
+    this.active.delete(sessionId);
+    logger.info('sessions', `Ended session ${sessionId}`);
+  }
+
+  // ── Session Messages ──
+
+  addMessage(sessionId, role, content, tokens = 0) {
+    this.storage.db.prepare(
+      'INSERT INTO session_messages (session_id, role, content, tokens) VALUES (?, ?, ?, ?)'
+    ).run(sessionId, role, content, tokens);
+
+    this.storage.db.prepare("UPDATE sessions SET updated_at = datetime('now') WHERE id = ?").run(sessionId);
+  }
+
+  getHistory(sessionId, limit = 50) {
+    return this.storage.db.prepare(
+      'SELECT role, content, created_at FROM session_messages WHERE session_id = ? ORDER BY created_at ASC LIMIT ?'
+    ).all(sessionId, limit);
+  }
+
+  clearHistory(sessionId) {
+    this.storage.db.prepare('DELETE FROM session_messages WHERE session_id = ?').run(sessionId);
+  }
+
+  // ── Session AI Processing ──
+
+  async process(sessionId, message) {
+    const session = this.get(sessionId);
+    if (!session) throw new Error('Session not found: ' + sessionId);
+
+    // Save user message
+    this.addMessage(sessionId, 'user', message);
+
+    // Build messages array
+    const history = this.getHistory(sessionId);
+    const model = session.model || this.engine.config.ai?.defaultModel;
+
+    // Get system prompt
+    let systemPrompt = session.system_prompt || session.systemPrompt;
+    if (!systemPrompt && session.type === 'main') {
+      // Use agent's normal prompt for main sessions
+      const agent = this.engine.agents?.get(session.agent_id);
+      if (agent?.promptBuilder) {
+        systemPrompt = await agent.promptBuilder.build(agent, session.contact_id, message);
+      }
+    }
+
+    const messages = [];
+    if (systemPrompt) messages.push({ role: 'system', content: systemPrompt });
+    messages.push(...history.map(h => ({ role: h.role === 'system' ? 'user' : h.role, content: h.content })));
+
+    // Call AI
+    const response = await this.engine.aiGateway.chat(messages, {
+      model,
+      fallbackChain: this.engine.config.ai?.fallbackChain,
+    });
+
+    // Save assistant response
+    this.addMessage(sessionId, 'assistant', response.content, response.outputTokens);
+
+    // Track usage
+    await this.storage.trackUsage(session.agent_id, response.model, response.inputTokens, response.outputTokens, response.costUsd);
+
+    logger.info('sessions', `Session ${sessionId} processed (${response.model}, ${response.outputTokens} tokens)`);
+
+    return {
+      content: response.content,
+      model: response.model,
+      tokens: response.inputTokens + response.outputTokens,
+      cost: response.costUsd,
+      sessionId,
+    };
+  }
+
+  // ── Sub-agent spawning with auto-completion ──
+
+  async runTask(agentId, contactId, task, options = {}) {
+    const session = this.spawn(agentId, contactId, {
+      type: 'isolated',
+      task,
+      model: options.model,
+      label: options.label || task.slice(0, 50),
+    });
+
+    const timeout = options.timeout || 60000;
+
+    try {
+      const result = await Promise.race([
+        this.process(session.id, task),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Task timeout')), timeout)),
+      ]);
+
+      this.end(session.id);
+      return { ...result, status: 'complete' };
+    } catch (err) {
+      this.end(session.id);
+      return { content: 'Task failed: ' + err.message, status: 'error', sessionId: session.id };
+    }
+  }
+
+  // ── Send message to another session ──
+
+  async send(targetSessionId, message) {
+    const session = this.get(targetSessionId);
+    if (!session) throw new Error('Session not found');
+    return this.process(targetSessionId, message);
+  }
+
+  // ── Stats ──
+
+  getStats(agentId) {
+    const active = this.storage.db.prepare(
+      "SELECT COUNT(*) as c FROM sessions WHERE agent_id = ? AND status = 'active'"
+    ).get(agentId)?.c || 0;
+
+    const total = this.storage.db.prepare(
+      'SELECT COUNT(*) as c FROM sessions WHERE agent_id = ?'
+    ).get(agentId)?.c || 0;
+
+    const messages = this.storage.db.prepare(
+      'SELECT COUNT(*) as c FROM session_messages sm JOIN sessions s ON sm.session_id = s.id WHERE s.agent_id = ?'
+    ).get(agentId)?.c || 0;
+
+    return { active, total, messages };
+  }
+}

package/lib/middleware/commands.js

@@ -145,6 +145,39 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/sessions') {
+    if (!ctx.engine.sessions) { await ctx.reply('❌ Sessions not available'); return; }
+    const args = msg.slice(10).trim();
+    
+    if (args.startsWith('new ')) {
+      const task = args.slice(4).trim();
+      await ctx.reply('🔄 Spawning session: ' + task.slice(0, 50) + '...');
+      const result = await ctx.engine.sessions.runTask(ctx.agentId, ctx.contactId, task);
+      await ctx.reply('✅ *Session Complete*\n\n' + result.content.slice(0, 2000));
+      return;
+    }
+    
+    if (args === 'stats') {
+      const stats = ctx.engine.sessions.getStats(ctx.agentId);
+      await ctx.reply('📊 *Sessions*\n\n🟢 Active: ' + stats.active + '\n📝 Total: ' + stats.total + '\n💬 Messages: ' + stats.messages);
+      return;
+    }
+    
+    if (args.startsWith('end ')) {
+      ctx.engine.sessions.end(args.slice(4).trim());
+      await ctx.reply('✅ Session ended');
+      return;
+    }
+
+    const sessions = ctx.engine.sessions.list(ctx.agentId, ctx.contactId, { limit: 10 });
+    if (sessions.length === 0) { await ctx.reply('📋 No active sessions'); return; }
+    const lines = sessions.map(s =>
+      (s.status === 'active' ? '🟢' : '⚫') + ' *' + (s.label || 'Untitled') + '*\n   Type: ' + s.type + '\n   ID: `' + s.id + '`'
+    );
+    await ctx.reply('📋 *Sessions*\n\n' + lines.join('\n\n') + '\n\n/sessions new <task> — spawn\n/sessions end <id> — close\n/sessions stats');
+    return;
+  }
+
   if (cmd === '/cron') {
     const args = msg.slice(6).trim();
     if (!ctx.engine.cron) { await ctx.reply('❌ Cron not available'); return; }

package/lib/middleware/response-sender.js

@@ -29,8 +29,9 @@ export async function responseSenderMiddleware(ctx, next) {
 
   // Send via appropriate channel
   if (ctx.platform === 'telegram' && tm) {
-    // Send file attachment (pptx, etc)
+    // Send file attachment (pptx, excel, pdf, html)
     if (response.filePath) {
+      logger.info('sender', 'SENDING FILE: ' + response.filePath);
       try {
         await tm.sendDocument(agentId, contactId, response.filePath, response.fileName, response.messages?.[0] || '');
         await next();

package/lib/tools/router.js

@@ -79,6 +79,18 @@ export class ToolRouter {
       'Example:',
       '---TOOL:pptx_slides:AI Report|dark|## Introduction\n- AI is transforming industries\n- Revenue growing 40% YoY\n\n## Growth [chart:bar]\n- 2020: 50\n- 2021: 80\n- 2022: 120\n- 2023: 200\n\n## Key Stats [stats]\n- 🌍 195 — Countries using AI\n- 💰 $500B — Market size\n- 🚀 40% — Annual growth---');
 
+    tools.push('', '### Spawn Sub-Agent Session',
+      '---TOOL:session_spawn:task description---',
+      'Spawn an isolated AI session to work on a task in the background. Returns when complete.',
+      'Use for: research, analysis, writing, any task that needs focused work.',
+      'Example: ---TOOL:session_spawn:Research the top 5 AI companies in Saudi Arabia and summarize their products---',
+      '', '### List Sessions',
+      '---TOOL:session_list:all---',
+      'Show all active sessions.',
+      '', '### Send to Session',
+      '---TOOL:session_send:session_id|message---',
+      'Send a follow-up message to an existing session.');
+
     tools.push('', '### Create Excel Spreadsheet (SENDS AS FILE!)',
       '---TOOL:excel:Title|theme|sheet content---',
       'Creates .xlsx file and sends it. Theme: blue, green, dark, red, saudi, corporate.',
@@ -246,7 +258,21 @@ export class ToolRouter {
   }
 
   async processResponse(response, agentId) {
-    const toolMatch = response.match(/---TOOL:(\w+):([\s\S]+?)---/);
+    const toolMatch = (() => {
+      const startIdx = response.indexOf('---TOOL:');
+      if (startIdx === -1) return null;
+      const afterTag = response.slice(startIdx + 8);
+      const colonIdx = afterTag.indexOf(':');
+      if (colonIdx === -1) return null;
+      const toolName = afterTag.slice(0, colonIdx);
+      const rest = afterTag.slice(colonIdx + 1);
+      // Find the closing --- that's NOT part of markdown (look for last --- or ---END---)
+      let endIdx = rest.lastIndexOf('---');
+      if (endIdx <= 0) return null;
+      const toolArg = rest.slice(0, endIdx);
+      const fullMatch = response.slice(startIdx, startIdx + 8 + colonIdx + 1 + endIdx + 3);
+      return [fullMatch, toolName, toolArg];
+    })();
     if (!toolMatch) return { toolUsed: false, toolResult: null, cleanResponse: response };
 
     const [fullMatch, toolName, toolArg] = toolMatch;
@@ -348,6 +374,43 @@ export class ToolRouter {
           }
           break;
         }
+        case 'session_spawn':
+        case 'spawn_session':
+        case 'subagent': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const result = await this._engine.sessions.runTask(
+              agentId, this._currentContactId || 'unknown', toolArg, { timeout: 120000 }
+            );
+            toolResult = result.status === 'complete' ?
+              'Sub-agent result:\n\n' + result.content :
+              'Sub-agent failed: ' + result.content;
+          } catch (err) { toolResult = 'Spawn failed: ' + err.message; }
+          break;
+        }
+        case 'session_list': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const sessions = this._engine.sessions.list(agentId, this._currentContactId);
+            if (sessions.length === 0) { toolResult = 'No active sessions'; break; }
+            toolResult = sessions.map(s =>
+              (s.status === 'active' ? '🟢' : '⚫') + ' ' + (s.label || s.id) + ' (' + s.type + ')\n   ID: ' + s.id
+            ).join('\n');
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'session_send': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const pipeIdx = toolArg.indexOf('|');
+            if (pipeIdx === -1) { toolResult = 'Format: session_id|message'; break; }
+            const sessId = toolArg.slice(0, pipeIdx).trim();
+            const msg = toolArg.slice(pipeIdx + 1).trim();
+            const result = await this._engine.sessions.send(sessId, msg);
+            toolResult = 'Session response:\n\n' + result.content;
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
         case 'excel':
         case 'xlsx':
         case 'spreadsheet': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {