morpheus-cli 0.3.8 → 0.4.1

package/dist/channels/telegram.js

@@ -23,6 +23,16 @@ export class TelegramAdapter {
     telephonistProvider = null;
     telephonistModel = null;
     history = new SQLiteChatMessageHistory({ sessionId: '' });
+    RATE_LIMIT_MS = 3000; // minimum ms between requests per user
+    rateLimiter = new Map(); // userId -> last request timestamp
+    isRateLimited(userId) {
+        const now = Date.now();
+        const last = this.rateLimiter.get(userId);
+        if (last !== undefined && now - last < this.RATE_LIMIT_MS)
+            return true;
+        this.rateLimiter.set(userId, now);
+        return false;
+    }
     HELP_MESSAGE = `/start - Show this welcome message and available commands
 /status - Check the status of the Morpheus agent
 /doctor - Diagnose environment and configuration issues
@@ -61,11 +71,16 @@ export class TelegramAdapter {
                     return; // Silent fail for security
                 }
                 this.display.log(`@${user}: ${text}`, { source: 'Telegram' });
-                // Handle system commands
+                // Handle system commands (commands bypass rate limit)
                 if (text.startsWith('/')) {
                     await this.handleSystemCommand(ctx, text, user);
                     return;
                 }
+                // Rate limit check
+                if (this.isRateLimited(userId)) {
+                    await ctx.reply('Please wait a moment before sending another message.');
+                    return;
+                }
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
@@ -96,6 +111,11 @@ export class TelegramAdapter {
                     this.display.log(`Unauthorized audio attempt by @${user} (ID: ${userId})`, { source: 'Telegram', level: 'warning' });
                     return;
                 }
+                // Rate limit check
+                if (this.isRateLimited(userId)) {
+                    await ctx.reply('Please wait a moment before sending another message.');
+                    return;
+                }
                 if (!config.audio.enabled) {
                     await ctx.reply("Audio transcription is currently disabled.");
                     return;

package/dist/http/api.js

@@ -80,12 +80,11 @@ export function createApiRouter(oracle) {
         }
     });
     router.get('/sessions/:id/messages', async (req, res) => {
+        const { id } = req.params;
+        const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
         try {
-            const { id } = req.params;
-            const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
             const messages = await sessionHistory.getMessages();
             // Normalize messages for UI
-            const key = (msg) => msg._getType(); // Access internal type if available, or infer
             const normalizedMessages = messages.map((msg) => {
                 const type = msg._getType ? msg._getType() : 'unknown';
                 return {
@@ -101,57 +100,23 @@ export function createApiRouter(oracle) {
         catch (err) {
             res.status(500).json({ error: err.message });
         }
+        finally {
+            sessionHistory.close();
+        }
     });
     // --- Chat Interaction ---
+    const ChatSchema = z.object({
+        message: z.string().min(1).max(32_000),
+        sessionId: z.string().min(1)
+    });
     router.post('/chat', async (req, res) => {
+        const parsed = ChatSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.message });
+        }
         try {
-            const { message, sessionId } = req.body;
-            if (!message || !sessionId) {
-                return res.status(400).json({ error: 'Message and Session ID are required' });
-            }
-            // We need to ensure the Oracle uses the correct session history.
-            // The Oracle class uses its own internal history instance.
-            // We might need to refactor Oracle to accept a session ID per request or 
-            // instantiate a temporary Oracle wrapper/context?
-            //
-            // ACTUALLY: The Oracle class uses `this.history`. 
-            // `SQLiteChatMessageHistory` takes `sessionId` in constructor.
-            // To support multi-session chat via API, we should probably allow passing sessionId to `chat()` 
-            // OR (cleaner for now) we can rely on the fact that `Oracle` might not support swapping sessions easily without
-            // re-initialization or we extend `oracle.chat` to support overriding session.
-            //
-            // Let's look at `Oracle.chat`: it uses `this.history`.
-            // And `SQLiteChatMessageHistory` is tied to a sessionId.
-            //
-            // Quick fix for this feature:
-            // We can use a trick: `Oracle` allows `overrides` in constructor but that's for db path.
-            // `Oracle` initializes `this.history` in `initialize`.
-            // Better approach:
-            // We can temporarily switch the session of the Oracle's history if it exposes it,
-            // OR we just instantiate a fresh history for the chat request and use the provider?
-            // No, `oracle.chat` encapsulates the provider invocation.
-            // Let's check `Oracle` class again. (I viewed it earlier).
-            // It has `private history`.
-            // SOLUTION:
-            // I will add a `setSessionId(id: string)` method to `Oracle` interface and class.
-            // OR pass `sessionId` to `chat`.
-            // For now, I will assume I can update `Oracle` to support dynamic sessions.
-            // I'll modify `Oracle.chat` signature in a separate step if needed. 
-            // Wait, `Oracle` is a singleton-ish in `start.ts`.
-            // Let's modify `Oracle` to accept `sessionId` in `chat`?
-            // `chat(message: string, extraUsage?: UsageMetadata, isTelephonist?: boolean)`
-            //
-            // Adding `sessionId` to `chat` seems invasive if not threaded fast.
-            //
-            // Alternative:
-            // `router.post('/chat')` instantiates a *new* Oracle? No, expensive (provider factory).
-            //
-            // Ideally `Oracle` should be stateless regarding session, or easily switchable.
-            // `SQLiteChatMessageHistory` is cheap to instantiate.
-            //
-            // Let's update `Oracle` to allow switching session.
-            // `oracle.switchSession(sessionId)`
-            await oracle.setSessionId(sessionId); // Type cast for now, will implement next
+            const { message, sessionId } = parsed.data;
+            await oracle.setSessionId(sessionId);
             const response = await oracle.chat(message);
             res.json({ response });
         }
@@ -248,6 +213,82 @@ export function createApiRouter(oracle) {
             res.status(500).json({ error: error.message });
         }
     });
+    // --- Model Pricing ---
+    const ModelPricingSchema = z.object({
+        provider: z.string().min(1),
+        model: z.string().min(1),
+        input_price_per_1m: z.number().nonnegative(),
+        output_price_per_1m: z.number().nonnegative()
+    });
+    router.get('/model-pricing', (req, res) => {
+        try {
+            const h = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+            const entries = h.listModelPricing();
+            h.close();
+            res.json(entries);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/model-pricing', (req, res) => {
+        const parsed = ModelPricingSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid payload', details: parsed.error.issues });
+        }
+        try {
+            const h = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+            h.upsertModelPricing(parsed.data);
+            h.close();
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.put('/model-pricing/:provider/:model', (req, res) => {
+        const { provider, model } = req.params;
+        const partial = z.object({
+            input_price_per_1m: z.number().nonnegative().optional(),
+            output_price_per_1m: z.number().nonnegative().optional()
+        }).safeParse(req.body);
+        if (!partial.success) {
+            return res.status(400).json({ error: 'Invalid payload', details: partial.error.issues });
+        }
+        try {
+            const h = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+            const existing = h.listModelPricing().find(e => e.provider === provider && e.model === model);
+            if (!existing) {
+                h.close();
+                return res.status(404).json({ error: 'Pricing entry not found' });
+            }
+            h.upsertModelPricing({
+                provider,
+                model,
+                input_price_per_1m: partial.data.input_price_per_1m ?? existing.input_price_per_1m,
+                output_price_per_1m: partial.data.output_price_per_1m ?? existing.output_price_per_1m
+            });
+            h.close();
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.delete('/model-pricing/:provider/:model', (req, res) => {
+        const { provider, model } = req.params;
+        try {
+            const h = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+            const changes = h.deleteModelPricing(provider, model);
+            h.close();
+            if (changes === 0)
+                return res.status(404).json({ error: 'Pricing entry not found' });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     // Calculate diff between two objects
     const getDiff = (obj1, obj2, prefix = '') => {
         const changes = [];

package/dist/runtime/memory/embedding.service.js

@@ -2,6 +2,8 @@ import { pipeline } from '@xenova/transformers';
 export class EmbeddingService {
     static instance;
     extractor;
+    MAX_CACHE_SIZE = 256;
+    cache = new Map(); // text prefix -> embedding
     constructor() { }
     static async getInstance() {
         if (!EmbeddingService.instance) {
@@ -12,10 +14,22 @@ export class EmbeddingService {
         return EmbeddingService.instance;
     }
     async generate(text) {
+        const cacheKey = text.slice(0, 200);
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
         const output = await this.extractor(text, {
             pooling: 'mean',
             normalize: true,
         });
-        return Array.from(output.data);
+        const embedding = Array.from(output.data);
+        if (this.cache.size >= this.MAX_CACHE_SIZE) {
+            // Evict oldest entry (FIFO)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(cacheKey, embedding);
+        return embedding;
     }
 }

package/dist/runtime/memory/sati/index.js

@@ -41,7 +41,7 @@ export class SatiMemoryMiddleware {
             return null;
         }
     }
-    async afterAgent(generatedResponse, history) {
+    async afterAgent(generatedResponse, history, userSessionId) {
         try {
             await this.service.evaluateAndPersist([
                 ...history.slice(-5).map(m => ({
@@ -49,7 +49,7 @@ export class SatiMemoryMiddleware {
                     content: m.content.toString()
                 })),
                 { role: 'assistant', content: generatedResponse }
-            ]);
+            ], userSessionId);
         }
         catch (error) {
             display.log(`Error in afterAgent: ${error}`, { source: 'Sati' });

package/dist/runtime/memory/sati/repository.js

@@ -83,6 +83,9 @@ export class SatiRepository {
       vec_rowid INTEGER NOT NULL
     );
 
+    CREATE INDEX IF NOT EXISTS idx_embedding_map_vec_rowid
+    ON memory_embedding_map(vec_rowid);
+
     -- ===============================
     -- 4️⃣ TRIGGERS FTS
     -- ===============================
@@ -129,6 +132,9 @@ export class SatiRepository {
       vec_rowid INTEGER NOT NULL
     );
 
+    CREATE INDEX IF NOT EXISTS idx_session_embedding_map_vec_rowid
+    ON session_embedding_map(vec_rowid);
+
   `);
     }
     // 🔥 NOVO — Salvar embedding
@@ -162,41 +168,47 @@ export class SatiRepository {
         transaction();
     }
     // 🔥 NOVO — Busca vetorial
-    searchByVector(embedding, limit) {
-        if (!this.db)
-            return [];
-        const SIMILARITY_THRESHOLD = 0.5; // ajuste fino depois
-        const stmt = this.db.prepare(`
-    SELECT 
-      m.*,
-      vec_distance_cosine(v.embedding, ?) as distance
-    FROM memory_vec v
-    JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
-    JOIN long_term_memory m ON m.id = map.memory_id
-    WHERE m.archived = 0
-    ORDER BY distance ASC
-    LIMIT ?
-  `);
-        const rows = stmt.all(new Float32Array(embedding), limit);
-        // 🔥 Filtrar por similaridade real
-        const ranked = rows
-            .map(r => ({
-            ...r,
-            similarity: 1 - r.distance
-        }))
-            .sort((a, b) => b.distance - a.distance);
-        const filtered = ranked
-            .filter(r => r.distance >= SIMILARITY_THRESHOLD)
-            .sort((a, b) => b.distance - a.distance);
-        if (filtered.length > 0) {
-            console.log(`[SatiRepository] Vector hit (${filtered.length})`);
-        }
-        return filtered.map(this.mapRowToRecord);
-    }
+    // private searchByVector(
+    //   embedding: number[],
+    //   limit: number
+    // ): IMemoryRecord[] {
+    //   if (!this.db) return [];
+    //   const SIMILARITY_THRESHOLD = 0.5; // ajuste fino depois
+    //   const stmt = this.db.prepare(`
+    //   SELECT 
+    //     m.*,
+    //     vec_distance_cosine(v.embedding, ?) as distance
+    //   FROM memory_vec v
+    //   JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
+    //   JOIN long_term_memory m ON m.id = map.memory_id
+    //   WHERE m.archived = 0
+    //   ORDER BY distance ASC
+    //   LIMIT ?
+    // `);
+    //   const rows = stmt.all(
+    //     new Float32Array(embedding),
+    //     limit
+    //   ) as any[];
+    //   // 🔥 Filtrar por similaridade real
+    //   const ranked = rows
+    //     .map(r => ({
+    //       ...r,
+    //       similarity: 1 - r.distance
+    //     }));
+    //   const filtered = ranked
+    //     .filter(r => r.distance >= SIMILARITY_THRESHOLD)
+    //     .sort((a, b) => b.similarity - a.similarity);
+    //   if (filtered.length > 0) {
+    //     console.log(
+    //       `[SatiRepository] Vector hit (${filtered.length})`
+    //     );
+    //   }
+    //   return filtered.map(this.mapRowToRecord);
+    // }
     searchUnifiedVector(embedding, limit) {
         if (!this.db)
             return [];
-        const SIMILARITY_THRESHOLD = 0.75;
+        const SIMILARITY_THRESHOLD = 0.8;
         const stmt = this.db.prepare(`
     SELECT *
     FROM (
@@ -208,7 +220,7 @@ export class SatiRepository {
         m.category as category,
         m.importance as importance,
         'long_term' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.7 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 1.7 as distance
       FROM memory_vec v
       JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
       JOIN long_term_memory m ON m.id = map.memory_id
@@ -224,7 +236,7 @@ export class SatiRepository {
         'session' as category,
         'medium' as importance,
         'session_chunk' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.3 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.5 as distance
       FROM session_vec v
       JOIN session_embedding_map map ON map.vec_rowid = v.rowid
       JOIN session_chunks sc ON sc.id = map.session_chunk_id
@@ -240,6 +252,8 @@ export class SatiRepository {
         // rows.forEach((row, index) => {
         //   console.log(`[SatiRepository] Row ${index + 1}:`, row);
         // });
+        // Note: the SQL query already computes distance as (1 - cosine_distance) * weight,
+        // so higher values mean higher similarity. Use distance directly as similarity score.
         const ranked = rows
             .map(r => ({
             ...r,

package/dist/runtime/memory/sati/service.js

@@ -50,7 +50,7 @@ export class SatiService {
             }))
         };
     }
-    async evaluateAndPersist(conversation) {
+    async evaluateAndPersist(conversation, userSessionId) {
         try {
             const satiConfig = ConfigManager.getInstance().getSatiConfig();
             if (!satiConfig)
@@ -74,7 +74,8 @@ export class SatiService {
                 new SystemMessage(SATI_EVALUATION_PROMPT),
                 new HumanMessage(JSON.stringify(inputPayload, null, 2))
             ];
-            const history = new SQLiteChatMessageHistory({ sessionId: 'sati-evaluation' });
+            const satiSessionId = userSessionId ? `sati-evaluation-${userSessionId}` : 'sati-evaluation';
+            const history = new SQLiteChatMessageHistory({ sessionId: satiSessionId });
             try {
                 const inputMsg = new ToolMessage({
                     content: JSON.stringify(inputPayload, null, 2),