morpheus-cli 0.4.15 → 0.5.1

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

@@ -60,7 +60,6 @@ export class SatiService {
             const agent = await ProviderFactory.create(satiConfig, []);
             // Get existing memories for context (Simulated "Working Memory" or full list if small)
             const allMemories = this.repository.getAllMemories();
-            const existingSummaries = allMemories.slice(0, 50).map(m => m.summary);
             // Map conversation to strict types and sanitize
             const recentConversation = conversation.map(c => ({
                 role: (c.role === 'human' ? 'user' : c.role),
@@ -68,7 +67,12 @@ export class SatiService {
             }));
             const inputPayload = {
                 recent_conversation: recentConversation,
-                existing_memory_summaries: existingSummaries
+                existing_memories: allMemories.map(m => ({
+                    id: m.id,
+                    category: m.category,
+                    importance: m.importance,
+                    summary: m.summary
+                }))
             };
             const messages = [
                 new SystemMessage(SATI_EVALUATION_PROMPT),
@@ -114,7 +118,7 @@ export class SatiService {
             }
             // Safe JSON parsing (handle markdown blocks if LLM wraps output)
             content = content.replace(/```json/g, '').replace(/```/g, '').trim();
-            let result = [];
+            let result = { inclusions: [], edits: [], deletions: [] };
             try {
                 result = JSON.parse(content);
             }
@@ -122,8 +126,10 @@ export class SatiService {
                 console.warn('[SatiService] Failed to parse JSON response:', content);
                 return;
             }
-            for (const item of result) {
-                if (item.should_store && item.summary && item.category && item.importance) {
+            const embeddingService = await EmbeddingService.getInstance();
+            // Process inclusions (new memories)
+            for (const item of (result.inclusions ?? [])) {
+                if (item.summary && item.category && item.importance) {
                     display.log(`Persisting new memory: [${item.category.toUpperCase()}] ${item.summary}`, { source: 'Sati' });
                     try {
                         const savedMemory = await this.repository.save({
@@ -134,22 +140,14 @@ export class SatiService {
                             hash: this.generateHash(item.summary),
                             source: 'conversation'
                         });
-                        // 🔥 GERAR EMBEDDING
-                        const embeddingService = await EmbeddingService.getInstance();
-                        const textForEmbedding = [
-                            savedMemory.summary,
-                            savedMemory.details ?? ''
-                        ].join(' ');
+                        const textForEmbedding = [savedMemory.summary, savedMemory.details ?? ''].join(' ');
                         const embedding = await embeddingService.generate(textForEmbedding);
                         display.log(`Generated embedding for memory ID ${savedMemory.id}`, { source: 'Sati', level: 'debug' });
-                        // 🔥 SALVAR EMBEDDING NO SQLITE_VEC
                         this.repository.upsertEmbedding(savedMemory.id, embedding);
-                        // Quiet success - logging handled by repository/middleware if needed, or verbose debug
                     }
                     catch (saveError) {
                         if (saveError.message && saveError.message.includes('UNIQUE constraint failed')) {
-                            // Duplicate detected by DB (Hash collision)
-                            // This is expected given T012 logic
+                            // Duplicate detected by DB (hash collision) — expected
                         }
                         else {
                             throw saveError;
@@ -157,6 +155,39 @@ export class SatiService {
                     }
                 }
             }
+            // Process edits (update existing memories)
+            for (const edit of (result.edits ?? [])) {
+                if (!edit.id)
+                    continue;
+                const updated = this.repository.update(edit.id, {
+                    importance: edit.importance,
+                    summary: edit.summary,
+                    details: edit.details,
+                });
+                if (updated) {
+                    display.log(`Updated memory ${edit.id}: ${edit.reason ?? ''}`, { source: 'Sati' });
+                    if (edit.summary || edit.details) {
+                        const text = [updated.summary, updated.details ?? ''].join(' ');
+                        const embedding = await embeddingService.generate(text);
+                        this.repository.upsertEmbedding(updated.id, embedding);
+                    }
+                }
+                else {
+                    display.log(`Edit skipped — memory not found: ${edit.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
+            // Process deletions (archive memories)
+            for (const deletion of (result.deletions ?? [])) {
+                if (!deletion.id)
+                    continue;
+                const archived = this.repository.archiveMemory(deletion.id);
+                if (archived) {
+                    display.log(`Archived memory ${deletion.id}: ${deletion.reason ?? ''}`, { source: 'Sati' });
+                }
+                else {
+                    display.log(`Deletion skipped — memory not found: ${deletion.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
         }
         catch (error) {
             console.error('[SatiService] Evaluation failed:', error);

package/dist/runtime/memory/sati/system-prompts.js

@@ -1,13 +1,27 @@
 export const SATI_EVALUATION_PROMPT = `You are **Sati**, an autonomous background memory manager for an AI assistant.
-Your goal is to analyze the conversation interaction and decide if any **Persistent Long-Term Memory** should be stored.
+Your goal is to analyze the conversation and decide what changes to make to the long-term memory store.
+You have full CRUD power: you can create new memories, edit existing ones, or delete memories that are no longer valid.
 
 ### INPUT DATA
-You will receive:
-1. A list of recent messages (USER and ASSISTANT).
-2. A list of ALREADY EXISTING memory summaries (to avoid duplicates).
+You will receive a JSON object with:
+1. \`recent_conversation\` — list of recent messages (user and assistant).
+2. \`existing_memories\` — full objects for all current memories (with IDs), so you can reference them for edits or deletions.
+
+Example input:
+\`\`\`json
+{
+  "recent_conversation": [
+    { "role": "user", "content": "..." },
+    { "role": "assistant", "content": "..." }
+  ],
+  "existing_memories": [
+    { "id": "uuid", "category": "preference", "importance": "medium", "summary": "..." }
+  ]
+}
+\`\`\`
 
 ### MEMORY CATEGORIES
-Classify any new memory into one of these types:
+Classify memories into one of these types:
 - **preference**: User preferences (e.g., "I like dark mode", "Use TypeScript").
 - **project**: Details about the user's projects, architecture, or tech stack.
 - **identity**: Facts about the user's identity, role, or background.
@@ -22,32 +36,60 @@ Classify any new memory into one of these types:
 - **professional_profile**: Job title, industry, skills.
 
 ### CRITICAL RULES
-0. **SAVE ON SUMMARY and REASONING IN ENGLISH AND NATIVE LANGUAGE**: Always generate a concise summary in English and, if the original information is in another language, also provide a summary in the original language. This ensures the memory is accessible and useful for future interactions, regardless of the language used.
-1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens. If found, ignore them explicitly.
-2. **NO DUPLICATES**: If the information is already covered by the \`existing_memory_summaries\`, DO NOT store it again.
-3. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
-4. **IMPORTANCE**: Assign 'low', 'medium', or 'high' importance. Store only 'medium' or 'high' unless it's a specific user preference (which is always important).
+0. **SUMMARIES IN ENGLISH AND NATIVE LANGUAGE**: Always write summaries in English. If the original content is in another language, also include a summary in that language (e.g., "Prefers TypeScript | Prefere TypeScript").
+1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens.
+2. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
+3. **NO PERSONAL FINANCIAL**: Avoid storing sensitive financial information (income, debts, expenses).
+4. **IMPORTANCE**: Assign 'low', 'medium', or 'high'. Prefer 'medium' or 'high' — only use 'low' for minor context.
+5. **OBEY THE USER**: If the user explicitly states something should be remembered, store it with at least 'medium' importance.
+
+### WHEN TO INCLUDE (create new memory)
+- The information is **genuinely new** and not covered by any entry in \`existing_memories\`.
+- Do NOT create a new entry if an existing memory already captures the same fact.
 
-### TOP IMPORTANT GUIDELINES
-5. **OBEY THE USER**: If the user explicitly states something should be remembered, it must be stored with at least 'medium' importance.
+### WHEN TO EDIT an existing memory
+- The user **confirmed or reinforced** an existing preference/fact → elevate importance (e.g., medium → high).
+- The existing memory is **slightly incorrect or outdated** → correct the summary.
+- The user provided **additional detail** about something already stored → update details field.
+- Use the **exact \`id\`** from \`existing_memories\`. Only include fields that actually change.
+- **Never duplicate** — if the info hasn't changed, do nothing.
+
+### WHEN TO DELETE an existing memory
+- The user **explicitly denied** a stored fact ("No, I don't prefer X", "That's wrong").
+- A memory was **proven false** during this conversation.
+- The user **explicitly asked to forget** something specific.
+- Use the **exact \`id\`** from \`existing_memories\`.
 
 ### OUTPUT FORMAT
-You MUST respond with a valid JSON object ARRAY matching the \`ISatiEvaluationOutputArray\` interface:
-[
-  {
-    "should_store": boolean,
-    "category": "category_name" | null,
-    "importance": "low" | "medium" | "high" | null,
-    "summary": "Concise factual statement | Summary in native language" | null,
-    "reason": "Why you decided to store or not store | Reason in native language"
-  },
-  {
-    "should_store": boolean,
-    "category": "category_name" | null,
-    "importance": "low" | "medium" | "high" | null,
-    "summary": "Concise factual statement | Summary in native language" | null,
-    "reason": "Why you decided to store or not store | Reason in native language"
-  },
-]
+Respond with a valid JSON object matching this structure. All three arrays are required (use empty arrays if nothing applies):
+
+\`\`\`json
+{
+  "inclusions": [
+    {
+      "category": "preference",
+      "importance": "high",
+      "summary": "Concise factual statement | Summary in native language",
+      "reason": "Why this is being stored"
+    }
+  ],
+  "edits": [
+    {
+      "id": "uuid-of-existing-memory",
+      "importance": "high",
+      "summary": "Updated summary if changed",
+      "details": "Updated details if changed",
+      "reason": "Why this is being edited"
+    }
+  ],
+  "deletions": [
+    {
+      "id": "uuid-of-existing-memory",
+      "reason": "Why this memory is being deleted"
+    }
+  ]
+}
+\`\`\`
 
+Empty arrays are perfectly valid. Only include fields in edits that actually need to change.
 `;

package/dist/runtime/memory/session-embedding-worker.js

@@ -10,7 +10,7 @@ const EMBEDDING_DIM = 384;
 const BATCH_LIMIT = 5;
 export async function runSessionEmbeddingWorker() {
     const display = DisplayManager.getInstance();
-    display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
+    // display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
     const shortDb = new Database(SHORT_DB_PATH);
     const satiDb = new Database(SATI_DB_PATH);
     shortDb.pragma('journal_mode = WAL');
@@ -27,7 +27,7 @@ export async function runSessionEmbeddingWorker() {
       LIMIT ?
     `).all(BATCH_LIMIT);
         if (sessions.length === 0) {
-            display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
+            // display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
             break;
         }
         for (const session of sessions) {
@@ -90,5 +90,5 @@ export async function runSessionEmbeddingWorker() {
             }
         }
     }
-    display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
+    // display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
 }

package/dist/runtime/memory/sqlite.js

@@ -290,6 +290,30 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to retrieve messages: ${error}`);
         }
     }
+    /**
+     * Retrieves raw stored messages for one or more session IDs.
+     * Useful when the caller needs metadata like session_id and created_at.
+     */
+    async getRawMessagesBySessionIds(sessionIds, limit = this.limit) {
+        if (sessionIds.length === 0) {
+            return [];
+        }
+        try {
+            const placeholders = sessionIds.map(() => '?').join(', ');
+            const stmt = this.db.prepare(`SELECT id, session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model
+         FROM messages
+         WHERE session_id IN (${placeholders})
+         ORDER BY id DESC
+         LIMIT ?`);
+            return stmt.all(...sessionIds, limit);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('SQLITE_BUSY')) {
+                throw new Error(`Database is locked. Please try again. Original error: ${error.message}`);
+            }
+            throw new Error(`Failed to retrieve raw messages: ${error}`);
+        }
+    }
     /**
      * Adds a message to the database.
      * @param message The message to add

package/dist/runtime/memory/trinity-db.js

@@ -0,0 +1,203 @@
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { homedir } from 'os';
+import { encrypt, decrypt, canEncrypt } from '../trinity-crypto.js';
+function safeDecrypt(value) {
+    if (!value)
+        return null;
+    try {
+        return decrypt(value);
+    }
+    catch {
+        return null;
+    }
+}
+function rowToRecord(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        host: row.host,
+        port: row.port,
+        database_name: row.database_name,
+        username: row.username,
+        password: safeDecrypt(row.password_encrypted),
+        connection_string: safeDecrypt(row.connection_string_encrypted),
+        schema_json: row.schema_json,
+        schema_updated_at: row.schema_updated_at,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        allow_read: row.allow_read === 1,
+        allow_insert: row.allow_insert === 1,
+        allow_update: row.allow_update === 1,
+        allow_delete: row.allow_delete === 1,
+        allow_ddl: row.allow_ddl === 1,
+    };
+}
+export class DatabaseRegistry {
+    static instance = null;
+    db;
+    constructor() {
+        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'trinity.db');
+        fs.ensureDirSync(path.dirname(dbPath));
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.ensureTable();
+        this.ensureMigrations();
+    }
+    static getInstance() {
+        if (!DatabaseRegistry.instance) {
+            DatabaseRegistry.instance = new DatabaseRegistry();
+        }
+        return DatabaseRegistry.instance;
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS databases (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        type TEXT NOT NULL,
+        host TEXT,
+        port INTEGER,
+        database_name TEXT,
+        username TEXT,
+        password_encrypted TEXT,
+        connection_string_encrypted TEXT,
+        schema_json TEXT,
+        schema_updated_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        allow_read INTEGER NOT NULL DEFAULT 1,
+        allow_insert INTEGER NOT NULL DEFAULT 0,
+        allow_update INTEGER NOT NULL DEFAULT 0,
+        allow_delete INTEGER NOT NULL DEFAULT 0,
+        allow_ddl INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    }
+    /** Add new columns to existing databases table (migration) */
+    ensureMigrations() {
+        const existingCols = this.db.pragma('table_info(databases)').map((c) => c.name);
+        const addIfMissing = (col, def) => {
+            if (!existingCols.includes(col)) {
+                this.db.exec(`ALTER TABLE databases ADD COLUMN ${col} ${def}`);
+            }
+        };
+        addIfMissing('allow_read', 'INTEGER NOT NULL DEFAULT 1');
+        addIfMissing('allow_insert', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_update', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_delete', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_ddl', 'INTEGER NOT NULL DEFAULT 0');
+    }
+    listDatabases() {
+        const rows = this.db.prepare('SELECT * FROM databases ORDER BY name ASC').all();
+        return rows.map(rowToRecord);
+    }
+    getDatabase(id) {
+        const row = this.db.prepare('SELECT * FROM databases WHERE id = ?').get(id);
+        return row ? rowToRecord(row) : null;
+    }
+    getDatabaseByName(name) {
+        const row = this.db.prepare('SELECT * FROM databases WHERE name = ?').get(name);
+        return row ? rowToRecord(row) : null;
+    }
+    createDatabase(data) {
+        if ((data.password || data.connection_string) && !canEncrypt()) {
+            throw new Error('MORPHEUS_SECRET must be set to store database credentials. ' +
+                'Add MORPHEUS_SECRET to your environment before saving credentials.');
+        }
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO databases (
+        name, type, host, port, database_name, username,
+        password_encrypted, connection_string_encrypted,
+        schema_json, schema_updated_at,
+        allow_read, allow_insert, allow_update, allow_delete, allow_ddl,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const result = stmt.run(data.name, data.type, data.host ?? null, data.port ?? null, data.database_name ?? null, data.username ?? null, data.password ? encrypt(data.password) : null, data.connection_string ? encrypt(data.connection_string) : null, data.allow_read !== false ? 1 : 0, data.allow_insert ? 1 : 0, data.allow_update ? 1 : 0, data.allow_delete ? 1 : 0, data.allow_ddl ? 1 : 0, now, now);
+        return this.getDatabase(result.lastInsertRowid);
+    }
+    updateDatabase(id, data) {
+        const existing = this.getDatabase(id);
+        if (!existing)
+            return null;
+        if ((data.password || data.connection_string) && !canEncrypt()) {
+            throw new Error('MORPHEUS_SECRET must be set to update database credentials.');
+        }
+        const now = Date.now();
+        // Build dynamic update
+        const fields = [];
+        const values = [];
+        if (data.name !== undefined) {
+            fields.push('name = ?');
+            values.push(data.name);
+        }
+        if (data.type !== undefined) {
+            fields.push('type = ?');
+            values.push(data.type);
+        }
+        if (data.host !== undefined) {
+            fields.push('host = ?');
+            values.push(data.host);
+        }
+        if (data.port !== undefined) {
+            fields.push('port = ?');
+            values.push(data.port);
+        }
+        if (data.database_name !== undefined) {
+            fields.push('database_name = ?');
+            values.push(data.database_name);
+        }
+        if (data.username !== undefined) {
+            fields.push('username = ?');
+            values.push(data.username);
+        }
+        if (data.password !== undefined) {
+            fields.push('password_encrypted = ?');
+            values.push(data.password ? encrypt(data.password) : null);
+        }
+        if (data.connection_string !== undefined) {
+            fields.push('connection_string_encrypted = ?');
+            values.push(data.connection_string ? encrypt(data.connection_string) : null);
+        }
+        if (data.allow_read !== undefined) {
+            fields.push('allow_read = ?');
+            values.push(data.allow_read ? 1 : 0);
+        }
+        if (data.allow_insert !== undefined) {
+            fields.push('allow_insert = ?');
+            values.push(data.allow_insert ? 1 : 0);
+        }
+        if (data.allow_update !== undefined) {
+            fields.push('allow_update = ?');
+            values.push(data.allow_update ? 1 : 0);
+        }
+        if (data.allow_delete !== undefined) {
+            fields.push('allow_delete = ?');
+            values.push(data.allow_delete ? 1 : 0);
+        }
+        if (data.allow_ddl !== undefined) {
+            fields.push('allow_ddl = ?');
+            values.push(data.allow_ddl ? 1 : 0);
+        }
+        if (fields.length === 0)
+            return existing;
+        fields.push('updated_at = ?');
+        values.push(now);
+        values.push(id);
+        this.db.prepare(`UPDATE databases SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+        return this.getDatabase(id);
+    }
+    deleteDatabase(id) {
+        const result = this.db.prepare('DELETE FROM databases WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    updateSchema(id, schemaJson) {
+        const now = Date.now();
+        this.db.prepare('UPDATE databases SET schema_json = ?, schema_updated_at = ?, updated_at = ? WHERE id = ?').run(schemaJson, now, now, id);
+    }
+}

package/dist/runtime/neo.js

@@ -0,0 +1,124 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderFactory } from "./providers/factory.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { Construtor } from "./tools/factory.js";
+import { morpheusTools } from "./tools/index.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { TaskRequestContext } from "./tasks/context.js";
+import { updateNeoDelegateToolDescription } from "./tools/neo-tool.js";
+export class Neo {
+    static instance = null;
+    static currentSessionId = undefined;
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    static setSessionId(sessionId) {
+        Neo.currentSessionId = sessionId;
+    }
+    static getInstance(config) {
+        if (!Neo.instance) {
+            Neo.instance = new Neo(config);
+        }
+        return Neo.instance;
+    }
+    static resetInstance() {
+        Neo.instance = null;
+    }
+    static async refreshDelegateCatalog() {
+        const mcpTools = await Construtor.create();
+        updateNeoDelegateToolDescription(mcpTools);
+    }
+    async initialize() {
+        const neoConfig = this.config.neo || this.config.llm;
+        const mcpTools = await Construtor.create();
+        const tools = [...mcpTools, ...morpheusTools];
+        updateNeoDelegateToolDescription(mcpTools);
+        this.display.log(`Neo initialized with ${tools.length} tools.`, { source: "Neo" });
+        try {
+            this.agent = await ProviderFactory.create(neoConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(neoConfig.provider, err, "Neo subagent initialization failed");
+        }
+    }
+    async execute(task, context, sessionId, taskContext) {
+        const neoConfig = this.config.neo || this.config.llm;
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Executing delegated task in Neo: ${task.slice(0, 80)}...`, {
+            source: "Neo",
+        });
+        const systemMessage = new SystemMessage(`
+You are Neo, an execution subagent in Morpheus.
+
+You execute tasks using MCP and internal tools.
+Focus on verifiable execution and return objective results.
+
+Rules:
+1. Use tools whenever the task depends on external/system state.
+2. Validate outputs before giving a final answer.
+3. If blocked, explain exactly what is missing — tool name, permission, or missing input.
+4. Keep output concise and actionable.
+5. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
+6. For connectivity checks, prefer dedicated network "ping" tool semantics and avoid forcing shell flags.
+7. If shell ping is required, include OS-aware guidance: Windows uses "-n", Linux/macOS uses "-c".
+
+CRITICAL — NEVER FABRICATE DATA:
+- If none of your available tools can retrieve the requested information, respond EXACTLY with:
+  "I do not have the required tool to fetch this data. Cannot retrieve: [describe what was requested]. Available tools: [list your actual tool names]."
+- NEVER generate fake records, fake IDs, fake names, fake statuses, or fake values of any kind.
+- If a tool call fails or returns empty results, report the actual result — do not substitute invented data.
+- An honest "I cannot retrieve this" is always correct. A fabricated answer is never acceptable.
+
+${context ? `Context:\n${context}` : ""}
+    `);
+        const userMessage = new HumanMessage(task);
+        const messages = [systemMessage, userMessage];
+        try {
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? "api",
+                session_id: taskContext?.session_id ?? sessionId ?? "default",
+                origin_message_id: taskContext?.origin_message_id,
+                origin_user_id: taskContext?.origin_user_id,
+            };
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === "string"
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            const targetSession = sessionId ?? Neo.currentSessionId ?? "neo";
+            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
+            try {
+                const persisted = new AIMessage(content);
+                persisted.usage_metadata = lastMessage.usage_metadata
+                    ?? lastMessage.response_metadata?.usage
+                    ?? lastMessage.response_metadata?.tokenUsage
+                    ?? lastMessage.usage;
+                persisted.provider_metadata = {
+                    provider: neoConfig.provider,
+                    model: neoConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
+            this.display.log("Neo task completed.", { source: "Neo" });
+            return content;
+        }
+        catch (err) {
+            throw new ProviderError(neoConfig.provider, err, "Neo task execution failed");
+        }
+    }
+    async reload() {
+        this.config = ConfigManager.getInstance().get();
+        this.agent = undefined;
+        await this.initialize();
+    }
+}