nyxora 26.7.2 → 26.7.3

package/packages/core/src/gateway/telegram.ts

@@ -1,7 +1,7 @@
 import { Bot, InlineKeyboard } from 'grammy';
 import { run } from '@grammyjs/runner';
 import { apiThrottler } from '@grammyjs/transformer-throttler';
-import { processUserInput, logger } from '../agent/reasoning';
+import { processUserInput, processUserInputStream, logger } from '../agent/reasoning';
 import { loadConfig, saveConfig } from '../config/parser';
 import { txManager } from '../agent/transactionManager';
 import { executeTransfer } from '../web3/skills/transfer';
@@ -29,17 +29,23 @@ export function formatToTelegramHTML(text: string): string {
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;');
     
-  html = html.replace(/\*\*(.*?)\*\*/g, '<b>$1</b>');
-  html = html.replace(/(?<!^|\n)\*(?!\s)(.*?)(?<!\s)\*/g, '<i>$1</i>');
-  html = html.replace(/_(.*?)_/g, '<i>$1</i>');
-  
-  html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
-  html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
-  
   html = html.replace(/&lt;thought&gt;[\s\S]*?&lt;\/thought&gt;\n?/g, '');
   html = html.replace(/<thought>[\s\S]*?<\/thought>\n?/g, '');
   html = html.replace(/&lt;think&gt;[\s\S]*?&lt;\/think&gt;\n?/g, '');
   html = html.replace(/<think>[\s\S]*?<\/think>\n?/g, '');
+
+  html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
+  html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+    
+  html = html.replace(/\*\*(.*?)\*\*/g, (match, p1) => {
+    if (p1.includes('<pre>') || p1.includes('<code>')) return match;
+    return `<b>${p1}</b>`;
+  });
+  
+  html = html.replace(/(?<!^|\n)\*(?!\s)(.*?)(?<!\s)\*/g, (match, p1) => {
+    if (p1.includes('<b>') || p1.includes('</b>') || p1.includes('<pre>') || p1.includes('<code>')) return match;
+    return `<i>${p1}</i>`;
+  });
   
   const tableRegex = /(?:\|.*\|(?:\n|$))+/g;
   html = html.replace(tableRegex, (match) => {
@@ -65,6 +71,19 @@ export function startTelegramBot() {
     const throttler = apiThrottler();
     bot.api.config.use(throttler);
     
+    bot.api.config.use(async (prev, method, payload, signal) => {
+      try {
+        return await prev(method, payload, signal);
+      } catch (err: any) {
+        if (method === 'getUpdates' && err.message?.includes('ETIMEDOUT')) {
+          console.log(pc.yellow('[Telegram] API connection lost (Timeout). Retrying automatically...'));
+        } else if (method === 'getUpdates') {
+          console.log(pc.yellow(`[Telegram] Failed to fetch updates: ${err.message}`));
+        }
+        throw err; // Rethrow so the runner can gracefully backoff and retry
+      }
+    });
+    
     const isPaired = !!config.integrations?.telegram?.authorized_chat_id;
     let generatedPin = '';
     let pinExpiry = 0;
@@ -122,7 +141,7 @@ export function startTelegramBot() {
     });
 
     bot.command('clear', async (ctx) => {
-      logger.clear(ctx.chat?.id.toString());
+      logger.clear(`telegram_${ctx.chat?.id}`);
       await ctx.reply("✅ AI memory has been cleared. Let's start a new chat!");
     });
 
@@ -131,36 +150,126 @@ export function startTelegramBot() {
       if (text.startsWith('/')) return;
 
       console.log(`[Telegram] Received from ${ctx.from?.first_name || 'User'}: ${text}`);
-      
       await ctx.replyWithChatAction('typing');
 
-      try {
-        let progressMsgId: number | null = null;
-        const onProgress = async (progressText: string) => {
+      // No need for a placeholder message anymore! We use ephemeral drafts.
+      const draft_id = Math.floor(Math.random() * 100000000) + 1;
+      let buffer = '';
+      let lastDraftAt = 0;
+      let isDrafting = false;
+      const THROTTLE_MS = 100; // Native drafts can be streamed incredibly fast
+
+      const onChunk = async (chunk: string) => {
+        buffer += chunk;
+        const now = Date.now();
+        if (!isDrafting && now - lastDraftAt >= THROTTLE_MS) {
+          isDrafting = true;
           try {
-            if (!progressMsgId) {
-              const sent = await ctx.reply(`<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
-              progressMsgId = sent.message_id;
-            } else {
-              await ctx.api.editMessageText(ctx.chat.id, progressMsgId, `<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
-            }
+            await ctx.api.sendMessageDraft(
+              ctx.chat.id, draft_id,
+              formatToTelegramHTML(buffer),
+              { parse_mode: 'HTML' } as any
+            );
           } catch {}
-        };
+          lastDraftAt = Date.now();
+          isDrafting = false;
+        }
+      };
 
-        const response = await processUserInput(text, 'user', onProgress, `telegram_${ctx.chat?.id}`);
+      const onProgress = async (msg: string) => {
+        if (!isDrafting) {
+          isDrafting = true;
+          try {
+            await ctx.api.sendMessageDraft(
+              ctx.chat.id, draft_id,
+              `<i>${msg.replace(/_/g, '')}</i>`,
+              { parse_mode: 'HTML' } as any
+            );
+          } catch {}
+          isDrafting = false;
+        }
+      };
 
-        if (progressMsgId) {
-          await ctx.api.deleteMessage(ctx.chat.id, progressMsgId).catch(() => {});
+      try {
+        const response = await processUserInputStream(
+          text, onChunk, onProgress, `telegram_${ctx.chat?.id}`
+        );
+
+        // Finalize by sending the permanent message (which replaces the draft)
+        let replyMarkup: any = undefined;
+        if (/Reply \*\*Yes\*\*/i.test(response) && /\*\*No\*\* to cancel/i.test(response)) {
+          replyMarkup = new InlineKeyboard()
+            .text('✅ Approve', 'tx_approve')
+            .text('❌ Reject', 'tx_reject');
         }
 
-        // Transactions will now use conversational approval (Zero-Latency text prompts) instead of InlineKeyboards.
-        await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML' });
+        await ctx.reply(
+          formatToTelegramHTML(response),
+          { parse_mode: 'HTML', reply_markup: replyMarkup }
+        ).catch((e) => {
+          console.error("[Telegram] CRITICAL: ctx.reply failed in text handler:", e.message);
+        });
       } catch (error: any) {
         console.error('[Telegram] Error processing message:', error);
-        await ctx.reply('❌ Sorry, I encountered an error while processing your message.');
+        await ctx.reply(
+          '❌ Sorry, I encountered an error while processing your message.',
+          {}
+        ).catch(() => {});
+      }
+    });
+
+    bot.on('callback_query:data', async (ctx) => {
+      const data = ctx.callbackQuery.data;
+      if (data === 'tx_approve' || data === 'tx_reject') {
+        await ctx.answerCallbackQuery().catch(() => {});
+        await ctx.editMessageReplyMarkup(undefined).catch(() => {});
+        
+        const simulatedText = data === 'tx_approve' ? 'yes' : 'no';
+        console.log(`[Telegram] User clicked ${simulatedText.toUpperCase()} via Inline Keyboard`);
+        
+        if (!ctx.chat) return;
+        await ctx.replyWithChatAction('typing');
+        
+        const draft_id = Math.floor(Math.random() * 100000000) + 1;
+        let buffer = '';
+        let lastDraftAt = 0;
+        let isDrafting = false;
+        
+        const onChunk = async (chunk: string) => {
+          buffer += chunk;
+          const now = Date.now();
+          if (!isDrafting && now - lastDraftAt >= 100) {
+            isDrafting = true;
+            try { await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, formatToTelegramHTML(buffer), { parse_mode: 'HTML' } as any); } catch {}
+            lastDraftAt = Date.now();
+            isDrafting = false;
+          }
+        };
+
+        const onProgress = async (msg: string) => {
+          if (!isDrafting) {
+            isDrafting = true;
+            try { await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, `<i>${msg.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' } as any); } catch {}
+            isDrafting = false;
+          }
+        };
+
+        try {
+          const response = await processUserInputStream(simulatedText, onChunk, onProgress, `telegram_${ctx.chat.id}`);
+          let replyMarkup: any = undefined;
+          if (/Reply \*\*Yes\*\*/i.test(response) && /\*\*No\*\* to cancel/i.test(response)) {
+            replyMarkup = new InlineKeyboard().text('✅ Approve', 'tx_approve').text('❌ Reject', 'tx_reject');
+          }
+          await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML', reply_markup: replyMarkup }).catch((e) => {
+             console.error("[Telegram] CRITICAL: ctx.reply failed in callback:", e.message);
+          });
+        } catch (error) {
+          await ctx.reply('❌ Sorry, I encountered an error.', {}).catch(() => {});
+        }
       }
     });
 
+
     bot.on('message:document', async (ctx) => {
       const doc = ctx.message.document;
       const caption = ctx.message.caption || '';
@@ -215,7 +324,9 @@ export function startTelegramBot() {
       console.error('[Telegram] Grammy error:', err);
     });
 
-    runnerInstance = run(bot);
+    runnerInstance = run(bot, {
+      runner: { silent: true }
+    });
     
     if (isPaired) {
       console.log('🤖 Telegram Bot is running and securely listening for your messages...');

package/packages/core/src/memory/episodic.ts

@@ -46,11 +46,17 @@ export class EpisodicMemoryDB {
       CREATE TABLE IF NOT EXISTS user_personas (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         trait TEXT UNIQUE NOT NULL,
+        category TEXT DEFAULT 'general',
         confidence REAL DEFAULT 0.1,
         source TEXT,
         lastUpdated DATETIME DEFAULT CURRENT_TIMESTAMP
       );
     `);
+
+    // Migration: add category column if missing (for older DBs)
+    try {
+      this.db.prepare('ALTER TABLE user_personas ADD COLUMN category TEXT DEFAULT \'general\'').run();
+    } catch {}
   }
 
   public addCandidateFact(fact: string, confidenceScore: number = 0.5, category: string = 'general', ruleType: 'temporary' | 'permanent' | 'observation' = 'observation', keyTopic?: string): void {
@@ -113,6 +119,11 @@ export class EpisodicMemoryDB {
     stmt.run();
   }
 
+  public clearAllPersonas(): void {
+    const stmt = this.db.prepare('DELETE FROM user_personas');
+    stmt.run();
+  }
+
   public close(): void {
     try {
       this.db.close();
@@ -120,7 +131,12 @@ export class EpisodicMemoryDB {
   }
 
   // --- PERSONA MODELING ---
-  public updatePersonaTrait(trait: string, confidence: number = 0.5, source: string = 'honcho'): void {
+
+  /**
+   * Legacy method: upsert by exact trait string.
+   * Kept for backward compatibility but prefer upsertPersonaByCategory.
+   */
+  public updatePersonaTrait(trait: string, confidence: number = 0.5, source: string = 'nyx_daemon'): void {
     const existing = this.db.prepare('SELECT id, confidence FROM user_personas WHERE trait = ?').get(trait) as any;
     
     if (existing) {
@@ -128,8 +144,37 @@ export class EpisodicMemoryDB {
       const stmt = this.db.prepare('UPDATE user_personas SET confidence = ?, source = ?, lastUpdated = CURRENT_TIMESTAMP WHERE id = ?');
       stmt.run(newConfidence, source, existing.id);
     } else {
-      const stmt = this.db.prepare('INSERT INTO user_personas (trait, confidence, source) VALUES (?, ?, ?)');
-      stmt.run(trait, confidence, source);
+      const stmt = this.db.prepare('INSERT INTO user_personas (trait, category, confidence, source) VALUES (?, ?, ?, ?)');
+      stmt.run(trait, 'general', confidence, source);
+    }
+  }
+
+  /**
+   * Category-based upsert: each category (language, tone, trading_style, behavior)
+   * has exactly ONE row in user_personas, identified by category.
+   * This ensures confidence accumulates correctly across audit cycles
+   * instead of creating duplicate rows with slightly different phrasing.
+   */
+  public upsertPersonaByCategory(
+    category: string,
+    value: string,
+    confidence: number = 0.5,
+    source: string = 'nyx_daemon'
+  ): void {
+    if (!value || !value.trim()) return;
+    const existing = this.db.prepare(
+      'SELECT id, confidence FROM user_personas WHERE category = ?'
+    ).get(category) as any;
+
+    if (existing) {
+      const newConfidence = Math.min(1.0, existing.confidence + (confidence * 0.2));
+      this.db.prepare(
+        'UPDATE user_personas SET trait = ?, confidence = ?, source = ?, lastUpdated = CURRENT_TIMESTAMP WHERE id = ?'
+      ).run(value.trim(), newConfidence, source, existing.id);
+    } else {
+      this.db.prepare(
+        'INSERT INTO user_personas (trait, category, confidence, source) VALUES (?, ?, ?, ?)'
+      ).run(value.trim(), category, confidence, source);
     }
   }
 
@@ -137,6 +182,22 @@ export class EpisodicMemoryDB {
     const stmt = this.db.prepare('SELECT * FROM user_personas ORDER BY confidence DESC');
     return stmt.all() as any[];
   }
+
+  /**
+   * Get personas filtered by minimum confidence threshold.
+   */
+  public getStrongPersonas(minConfidence: number = 0.5): any[] {
+    const stmt = this.db.prepare(
+      'SELECT * FROM user_personas WHERE confidence >= ? ORDER BY confidence DESC'
+    );
+    return stmt.all(minConfidence) as any[];
+  }
+
+  public deletePersonaByTrait(keyword: string): number {
+    const stmt = this.db.prepare('DELETE FROM user_personas WHERE trait LIKE ?');
+    const result = stmt.run(`%${keyword}%`);
+    return (result as any).changes || 0;
+  }
 }
 
 // Singleton instance

package/packages/core/src/memory/logger.ts

@@ -109,6 +109,34 @@ export class Logger {
       )
     `);
 
+    // V4: Transaction Persistence
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_transactions (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        chain_name TEXT NOT NULL,
+        details TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result TEXT,
+        nonce TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_withdrawals (
+        id TEXT PRIMARY KEY,
+        l2_tx_hash TEXT NOT NULL,
+        l1_chain TEXT NOT NULL,
+        l2_chain TEXT NOT NULL,
+        portal_address TEXT NOT NULL,
+        user_address TEXT NOT NULL,
+        amount TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
 
     // Ensure session_id exists for older DBs
     try {
@@ -195,7 +223,7 @@ export class Logger {
     `).all(term, term);
   }
 
-  public getHistory(sessionId?: string, limit: number = 40): MemoryEntry[] {
+  public getHistory(sessionId?: string, limit: number = 70): MemoryEntry[] {
     let rows;
     // Phase 2: Sliding Window Algorithm (LLM Context Limit)
     // Fetch only the last X messages, then order them chronologically
@@ -232,13 +260,42 @@ export class Logger {
     });
   }
 
+  /**
+   * Returns the N most recent messages across ALL sessions (including Telegram, Discord, and NULL sessions).
+   * Used by NyxDaemon to analyze conversation history from every channel.
+   */
+  public getRecentMessagesAllSessions(limit: number = 30): MemoryEntry[] {
+    const rows = this.db.prepare(`
+      SELECT * FROM (
+        SELECT role, content, name, tool_call_id, tool_calls, session_id, id
+        FROM messages
+        ORDER BY id DESC LIMIT ?
+      ) ORDER BY id ASC
+    `).all(limit);
+
+    return rows.map((row: any) => {
+      const entry: MemoryEntry = {
+        role: row.role,
+        content: row.content,
+      };
+      if (row.name) entry.name = row.name;
+      if (row.tool_call_id) entry.tool_call_id = row.tool_call_id;
+      if (row.tool_calls) entry.tool_calls = JSON.parse(row.tool_calls);
+      if (row.session_id) entry.session_id = row.session_id;
+      return entry;
+    });
+  }
+
+
   public addEntry(entry: MemoryEntry, sessionId?: string) {
     if (sessionId) {
       // Auto-create session if it doesn't exist (e.g. for Telegram integration)
       try {
         const sessionExists = this.db.prepare('SELECT 1 FROM sessions WHERE id = ?').get(sessionId);
         if (!sessionExists) {
-          const title = sessionId.startsWith('telegram_') ? `Telegram Chat` : 'New Session';
+          let title = 'New Session';
+          if (sessionId.startsWith('telegram_')) title = 'Telegram Chat';
+          else if (sessionId.startsWith('discord_')) title = 'Discord Chat';
           this.db.prepare('INSERT INTO sessions (id, title) VALUES (?, ?)').run(sessionId, title);
         }
       } catch {}
@@ -349,6 +406,89 @@ export class Logger {
     const result = this.db.prepare(`UPDATE limit_orders SET status = 'ACTIVE' WHERE id = ?`).run(orderId);
     return result.changes > 0;
   }
+
+  // V4: Transaction Persistence Methods
+  public savePendingTransaction(tx: any) {
+    this.db.prepare(`
+      INSERT INTO pending_transactions (id, type, chain_name, details, status, result, nonce, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        status = excluded.status,
+        result = excluded.result,
+        nonce = excluded.nonce
+    `).run(
+      tx.id,
+      tx.type,
+      tx.chainName,
+      JSON.stringify(tx.details),
+      tx.status,
+      tx.result || null,
+      tx.nonce || null,
+      tx.createdAt || Date.now()
+    );
+  }
+
+  public getPendingTransactions(): any[] {
+    const rows = this.db.prepare(`SELECT * FROM pending_transactions WHERE status = 'pending'`).all() as any[];
+    return rows.map(r => ({
+      id: r.id,
+      type: r.type,
+      chainName: r.chain_name,
+      details: JSON.parse(r.details),
+      status: r.status,
+      result: r.result,
+      nonce: r.nonce,
+      createdAt: r.created_at
+    }));
+  }
+
+  public getTransaction(id: string): any {
+    const r = this.db.prepare(`SELECT * FROM pending_transactions WHERE id = ?`).get(id) as any;
+    if (!r) return undefined;
+    return {
+      id: r.id,
+      type: r.type,
+      chainName: r.chain_name,
+      details: JSON.parse(r.details),
+      status: r.status,
+      result: r.result,
+      nonce: r.nonce,
+      createdAt: r.created_at
+    };
+  }
+
+  public savePendingWithdrawal(w: any) {
+    this.db.prepare(`
+      INSERT INTO pending_withdrawals (id, l2_tx_hash, l1_chain, l2_chain, portal_address, user_address, amount, status, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET status = excluded.status
+    `).run(
+      w.id,
+      w.l2TxHash,
+      w.l1Chain,
+      w.l2Chain,
+      w.portalAddress,
+      w.userAddress,
+      w.amount,
+      w.status,
+      w.createdAt || Date.now()
+    );
+  }
+
+  public getPendingWithdrawals(): any[] {
+    const rows = this.db.prepare(`SELECT * FROM pending_withdrawals WHERE status != 'COMPLETED'`).all() as any[];
+    return rows.map(r => ({
+      id: r.id,
+      l2TxHash: r.l2_tx_hash,
+      l1Chain: r.l1_chain,
+      l2Chain: r.l2_chain,
+      portalAddress: r.portal_address,
+      userAddress: r.user_address,
+      amount: r.amount,
+      status: r.status,
+      createdAt: r.created_at
+    }));
+  }
 }
 
 export const logger = new Logger();

package/packages/core/src/memory/promotionEngine.ts

@@ -39,21 +39,35 @@ export class PromotionEngine {
       const uniquePermanent = [...new Set(permanentPreferences)];
       const uniqueRecent = [...new Set(recentObservations)];
 
-      // 4. Rewrite user.md (The Golden Profile)
-      this.rewriteUserProfile(uniquePermanent, uniqueRecent);
+      // 4. Fetch Persona Traits
+      const personas = episodicDB.getStrongPersonas(0.4);
+      const personaStrings: string[] = [];
+      for (const p of personas) {
+        personaStrings.push(`- [${p.category.toUpperCase()}] ${p.trait}`);
+      }
+
+      // 5. Rewrite user.md (The Golden Profile)
+      this.rewriteUserProfile(uniquePermanent, uniqueRecent, personaStrings);
 
     } catch (error) {
       console.error('[PromotionEngine] Error running promotion engine:', error);
     }
   }
 
-  private static rewriteUserProfile(permanent: string[], recent: string[]): void {
+  private static rewriteUserProfile(permanent: string[], recent: string[], personas: string[] = []): void {
     const userMdPath = getPath('user.md');
 
     let newContent = `Write custom instructions, special rules, user profiles, or the persona you want for Nyxora AI in this file.\n\n`;
     newContent += `<!-- AUTOMANAGED BY PROMOTION ENGINE. MANUAL EDITS MAY BE OVERWRITTEN -->\n\n`;
 
-    newContent += `# Permanent Preferences\n`;
+    newContent += `# User Persona & Identity\n`;
+    if (personas.length === 0) {
+      newContent += `*(No specific persona traits identified yet)*\n`;
+    } else {
+      newContent += personas.join('\n') + '\n';
+    }
+
+    newContent += `\n# Permanent Preferences\n`;
     if (permanent.length === 0) {
       newContent += `*(No permanent preferences recorded yet)*\n`;
     } else {
@@ -68,6 +82,6 @@ export class PromotionEngine {
     }
 
     fs.writeFileSync(userMdPath, newContent, 'utf-8');
-    console.log(`[PromotionEngine] user.md successfully synchronized with Layer 2 Episodic Memory.`);
+    console.log(`[PromotionEngine] user.md successfully synchronized with Layer 2 Episodic Memory and Personas.`);
   }
 }

package/packages/core/src/system/agentskills.ts

@@ -155,6 +155,16 @@ export class AgentSkills {
       throw new Error(`Execution script not found for skill '${name}' at path: ${scriptPath}`);
     }
 
+    // Automatically load .env for the skill if it exists
+    const envPath = path.join(this.skillsDir, name, '.env');
+    if (fs.existsSync(envPath)) {
+      try {
+        require('dotenv').config({ path: envPath });
+      } catch (e) {
+        console.warn(`[AgentSkills] Failed to load .env for skill '${name}':`, e);
+      }
+    }
+
     try {
       // Dynamic import of the TS/JS module
       const module = await import(scriptPath);

package/packages/core/src/system/plugins/GoogleWorkspacePlugin.ts

@@ -15,7 +15,7 @@ import {
 export class GoogleWorkspacePlugin implements Plugin {
   public name = 'GoogleWorkspacePlugin';
   public description = 'Google Workspace operations including Gmail, Calendar, Docs, and Sheets.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     readGmailInboxToolDefinition,

package/packages/core/src/system/plugins/SystemCorePlugin.ts

@@ -9,7 +9,7 @@ import { forgetMemoryToolDefinition, forgetMemory } from '../skills/forgetMemory
 export class SystemCorePlugin implements Plugin {
   public name = 'SystemCorePlugin';
   public description = 'Core system identity, profile, and task scheduling operations.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     updateProfileToolDefinition,

package/packages/core/src/system/plugins/SystemExternalPlugin.ts

@@ -4,7 +4,7 @@ import { createAgentSkillToolDefinition, createAgentSkill } from '../skills/crea
 export class SystemExternalPlugin implements Plugin {
   public name = 'SystemExternalPlugin';
   public description = 'Provides tools for creating and managing third-party external agent skills.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     createAgentSkillToolDefinition

package/packages/core/src/system/plugins/SystemPluginInstallerPlugin.ts

@@ -22,7 +22,7 @@ const installPluginDefinition = {
 export class SystemPluginInstallerPlugin implements Plugin {
   public name = 'SystemPluginInstallerPlugin';
   public description = 'Autonomous package manager for installing and auto-healing dynamic plugins.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [installPluginDefinition];
 

package/packages/core/src/system/plugins/SystemSocialPlugin.ts

@@ -5,7 +5,7 @@ import { notionWorkspaceToolDefinition, manageNotion } from '../skills/notionWor
 export class SystemSocialPlugin implements Plugin {
   public name = 'SystemSocialPlugin';
   public description = 'Social media and external workspace operations (Twitter, Notion).';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     xManagerToolDefinition,

package/packages/core/src/system/plugins/SystemWebPlugin.ts

@@ -8,7 +8,7 @@ import { audioTranscribeToolDefinition, transcribeAudio } from '../skills/audioT
 export class SystemWebPlugin implements Plugin {
   public name = 'SystemWebPlugin';
   public description = 'Web browsing, searching, and media analysis operations.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     browseWebsiteToolDefinition,

package/packages/core/src/system/plugins/SystemWorkspacePlugin.ts

@@ -10,7 +10,7 @@ import { createCognitiveSkillToolDefinition, createCognitiveSkill } from '../ski
 export class SystemWorkspacePlugin implements Plugin {
   public name = 'SystemWorkspacePlugin';
   public description = 'Local system operations including file management, terminal execution, and Git.';
-  public version = '1.0.0';
+  public version = '1.0.1';
 
   public tools = [
     readLocalFileToolDefinition,
@@ -32,8 +32,8 @@ export class SystemWorkspacePlugin implements Plugin {
     ['edit_local_file']: async (args: any) => {
       return await editLocalFile(args.filePath, args.searchString, args.replacementString);
     },
-    ['generate_excel_report']: async (args: any) => {
-      return await generateExcelFile(args.data, args.filename);
+    ['generate_excel_file']: async (args: any) => {
+      return await generateExcelFile(args.data, args.filePath);
     },
     ['run_terminal_command']: async (args: any) => {
       return await runTerminalCommand(args.command);

package/packages/core/src/system/plugins/createSkill.ts

@@ -4,7 +4,7 @@ import { logger } from '../../agent/reasoning';
 
 export class CreateSkillPlugin implements Plugin {
   public name = 'CreateSkill';
-  public version = '1.0.0';
+  public version = '1.0.1';
   public description = 'Autonomously extracts and creates skills for Nyxora.';
 
   public tools = [