morpheus-cli 0.1.3 → 0.1.5

package/README.md

@@ -85,6 +85,16 @@ Morpheus is built with **Node.js** and **TypeScript**, using **LangChain** as th
 - **Configuration (`src/config/`)**: Singleton-based configuration manager using `zod` for validation and `js-yaml` for persistence (`~/.morpheus/config.yaml`).
 - **Channels (`src/channels/`)**: Adapters for external communication. Currently supports Telegram (`telegraf`) with strict user whitelisting.
 
+## Features
+
+### 🎙️ Audio Transcription (Telegram)
+Send voice messages directly to the Telegram bot. Morpheus will:
+1. Transcribe the audio using **Google Gemini**.
+2. Process the text as a standard prompt.
+3. Reply with the answer.
+
+*Requires a Google Gemini API Key.*
+
 ## Development Setup
 
 This guide is for developers contributing to the Morpheus codebase.
@@ -139,11 +149,19 @@ llm:
   model: "gpt-4-turbo"
   temperature: 0.7
   api_key: "sk-..."
+memory:
+  limit: 100 # Number of messages to retain in context
 channels:
   telegram:
     enabled: true
     token: "YOUR_TELEGRAM_BOT_TOKEN"
     allowedUsers: ["123456789"] # Your Telegram User ID
+
+# Audio Transcription Support
+audio:
+  enabled: true
+  apiKey: "YOUR_GEMINI_API_KEY" # Optional if llm.provider is 'gemini'
+  maxDurationSeconds: 300
 ```
 
 ## Testing

package/dist/channels/telegram.js

@@ -1,11 +1,19 @@
 import { Telegraf } from 'telegraf';
+import { message } from 'telegraf/filters';
 import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from '../runtime/display.js';
+import { AudioAgent } from '../runtime/audio-agent.js';
 export class TelegramAdapter {
     bot = null;
     isConnected = false;
     display = DisplayManager.getInstance();
+    config = ConfigManager.getInstance();
     agent;
+    audioAgent = new AudioAgent();
     constructor(agent) {
         this.agent = agent;
     }
@@ -52,6 +60,75 @@ export class TelegramAdapter {
                     }
                 }
             });
+            // Handle Voice Messages
+            this.bot.on(message('voice'), async (ctx) => {
+                const user = ctx.from.username || ctx.from.first_name;
+                const userId = ctx.from.id.toString();
+                const config = this.config.get();
+                // AUTH GUARD
+                if (!this.isAuthorized(userId, allowedUsers)) {
+                    this.display.log(`Unauthorized audio attempt by @${user} (ID: ${userId})`, { source: 'Telegram', level: 'warning' });
+                    return;
+                }
+                if (!config.audio.enabled) {
+                    await ctx.reply("Audio transcription is currently disabled.");
+                    return;
+                }
+                const apiKey = config.audio.apiKey || (config.llm.provider === 'gemini' ? config.llm.api_key : undefined);
+                if (!apiKey) {
+                    this.display.log(`Audio transcription failed: No Gemini API key available`, { source: 'AgentAudio', level: 'error' });
+                    await ctx.reply("Audio transcription requires a Gemini API key. Please configure `audio.apiKey` or set LLM provider to Gemini.");
+                    return;
+                }
+                const duration = ctx.message.voice.duration;
+                if (duration > config.audio.maxDurationSeconds) {
+                    await ctx.reply(`Voice message too long. Max duration is ${config.audio.maxDurationSeconds}s.`);
+                    return;
+                }
+                this.display.log(`Receiving voice message from @${user} (${duration}s)...`, { source: 'AgentAudio' });
+                let filePath = null;
+                let listeningMsg = null;
+                try {
+                    listeningMsg = await ctx.reply("🎧Escutando...");
+                    // Download
+                    this.display.log(`Downloading audio for @${user}...`, { source: 'AgentAudio' });
+                    const fileLink = await ctx.telegram.getFileLink(ctx.message.voice.file_id);
+                    filePath = await this.downloadToTemp(fileLink);
+                    // Transcribe
+                    this.display.log(`Transcribing audio for @${user}...`, { source: 'AgentAudio' });
+                    const text = await this.audioAgent.transcribe(filePath, 'audio/ogg', apiKey);
+                    this.display.log(`Transcription success for @${user}: "${text}"`, { source: 'AgentAudio', level: 'success' });
+                    // Reply with transcription (optional, maybe just process it?)
+                    // The prompt says "reply with the answer".
+                    // "Transcribe them... and process the resulting text as a standard user prompt."
+                    // So I should treat 'text' as if it was a text message.
+                    await ctx.reply(`🎤 *Transcription*: _"${text}"_`, { parse_mode: 'Markdown' });
+                    await ctx.sendChatAction('typing');
+                    // Process with Agent
+                    const response = await this.agent.chat(text);
+                    // if (listeningMsg) {
+                    //   try {
+                    //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);
+                    //   } catch (e) {
+                    //     // Ignore delete error
+                    //   }
+                    // }
+                    if (response) {
+                        await ctx.reply(response);
+                        this.display.log(`Responded to @${user} (via audio)`, { source: 'Telegram' });
+                    }
+                }
+                catch (error) {
+                    this.display.log(`Audio processing error for @${user}: ${error.message}`, { source: 'AgentAudio', level: 'error' });
+                    await ctx.reply("Sorry, I failed to process your audio message.");
+                }
+                finally {
+                    // Cleanup
+                    if (filePath && await fs.pathExists(filePath)) {
+                        await fs.unlink(filePath).catch(() => { });
+                    }
+                }
+            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -71,6 +148,17 @@ export class TelegramAdapter {
     isAuthorized(userId, allowedUsers) {
         return allowedUsers.includes(userId);
     }
+    async downloadToTemp(url, extension = '.ogg') {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to download audio: ${response.statusText}`);
+        const tmpDir = os.tmpdir();
+        const fileName = `morpheus-audio-${Date.now()}${extension}`;
+        const filePath = path.join(tmpDir, fileName);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        await fs.writeFile(filePath, buffer);
+        return filePath;
+    }
     async disconnect() {
         if (!this.isConnected || !this.bot) {
             return;

package/dist/cli/commands/init.js

@@ -10,17 +10,19 @@ export const initCommand = new Command('init')
     .action(async () => {
     const display = DisplayManager.getInstance();
     renderBanner();
+    const configManager = ConfigManager.getInstance();
+    const currentConfig = await configManager.load();
     // Ensure directory exists
     await scaffold();
     display.log(chalk.blue('Let\'s set up your Morpheus agent!'));
     try {
         const name = await input({
             message: 'Name your agent:',
-            default: 'morpheus',
+            default: currentConfig.agent.name,
         });
         const personality = await input({
             message: 'Describe its personality:',
-            default: 'helpful and concise',
+            default: currentConfig.agent.personality,
         });
         const provider = await select({
             message: 'Select LLM Provider:',
@@ -30,6 +32,7 @@ export const initCommand = new Command('init')
                 { name: 'Ollama', value: 'ollama' },
                 { name: 'Google Gemini', value: 'gemini' },
             ],
+            default: currentConfig.llm.provider,
         });
         let defaultModel = 'gpt-3.5-turbo';
         switch (provider) {
@@ -46,17 +49,23 @@ export const initCommand = new Command('init')
                 defaultModel = 'gemini-pro';
                 break;
         }
+        if (provider === currentConfig.llm.provider) {
+            defaultModel = currentConfig.llm.model;
+        }
         const model = await input({
             message: 'Enter Model Name:',
             default: defaultModel,
         });
         let apiKey;
+        const hasExistingKey = !!currentConfig.llm.api_key;
+        const apiKeyMessage = hasExistingKey
+            ? 'Enter API Key (leave empty to preserve existing, or if using env vars):'
+            : 'Enter API Key (leave empty if using env vars):';
         if (provider !== 'ollama') {
             apiKey = await password({
-                message: 'Enter API Key (leave empty if using env vars):',
+                message: apiKeyMessage,
             });
         }
-        const configManager = ConfigManager.getInstance();
         // Update config
         await configManager.set('agent.name', name);
         await configManager.set('agent.personality', personality);
@@ -65,33 +74,81 @@ export const initCommand = new Command('init')
         if (apiKey) {
             await configManager.set('llm.api_key', apiKey);
         }
+        // Audio Configuration
+        const audioEnabled = await confirm({
+            message: 'Enable Audio Transcription? (Requires Gemini)',
+            default: currentConfig.audio?.enabled || false,
+        });
+        let audioKey;
+        let finalAudioEnabled = audioEnabled;
+        if (audioEnabled) {
+            if (provider === 'gemini') {
+                display.log(chalk.gray('Using main Gemini API key for audio.'));
+            }
+            else {
+                const hasExistingAudioKey = !!currentConfig.audio?.apiKey;
+                const audioKeyMessage = hasExistingAudioKey
+                    ? 'Enter Gemini API Key for Audio (leave empty to preserve existing):'
+                    : 'Enter Gemini API Key for Audio:';
+                audioKey = await password({
+                    message: audioKeyMessage,
+                });
+                // Check if we have a valid key (new or existing)
+                const effectiveKey = audioKey || currentConfig.audio?.apiKey;
+                if (!effectiveKey) {
+                    display.log(chalk.yellow('Audio disabled: Missing Gemini API Key required when using non-Gemini LLM provider.'));
+                    finalAudioEnabled = false;
+                }
+            }
+        }
+        await configManager.set('audio.enabled', finalAudioEnabled);
+        if (audioKey) {
+            await configManager.set('audio.apiKey', audioKey);
+        }
         // External Channels Configuration
         const configureChannels = await confirm({
             message: 'Do you want to configure external channels?',
-            default: false,
+            default: currentConfig.channels.telegram?.enabled || false,
         });
         if (configureChannels) {
             const channels = await checkbox({
                 message: 'Select channels to enable:',
                 choices: [
-                    { name: 'Telegram', value: 'telegram' },
+                    {
+                        name: 'Telegram',
+                        value: 'telegram',
+                        checked: currentConfig.channels.telegram?.enabled || false
+                    },
                 ],
             });
             if (channels.includes('telegram')) {
                 display.log(chalk.yellow('\n--- Telegram Configuration ---'));
                 display.log(chalk.gray('1. Create a bot via @BotFather to get your token.'));
                 display.log(chalk.gray('2. Get your User ID via @userinfobot.\n'));
+                const hasExistingToken = !!currentConfig.channels.telegram?.token;
                 const token = await password({
-                    message: 'Enter Telegram Bot Token:',
-                    validate: (value) => value.length > 0 || 'Token is required.'
+                    message: hasExistingToken
+                        ? 'Enter Telegram Bot Token (leave empty to preserve existing):'
+                        : 'Enter Telegram Bot Token:',
+                    validate: (value) => {
+                        if (value.length > 0)
+                            return true;
+                        if (hasExistingToken)
+                            return true;
+                        return 'Token is required.';
+                    }
                 });
+                const defaultUsers = currentConfig.channels.telegram?.allowedUsers?.join(', ') || '';
                 const allowedUsersInput = await input({
                     message: 'Enter Allowed User IDs (comma separated):',
+                    default: defaultUsers,
                     validate: (value) => value.length > 0 || 'At least one user ID is required for security.'
                 });
                 const allowedUsers = allowedUsersInput.split(',').map(id => id.trim()).filter(id => id.length > 0);
                 await configManager.set('channels.telegram.enabled', true);
-                await configManager.set('channels.telegram.token', token);
+                if (token) {
+                    await configManager.set('channels.telegram.token', token);
+                }
                 await configManager.set('channels.telegram.allowedUsers', allowedUsers);
             }
         }

package/dist/cli/commands/start.js

@@ -130,7 +130,7 @@ export const startCommand = new Command('start')
             });
         }
         // Keep process alive (Mock Agent Loop)
-        display.startSpinner('Agent active and listening... (Press ESC to stop)');
+        display.startSpinner('Agent active and listening... (Press ctrl+c to stop)');
         // Prevent node from exiting
         setInterval(() => {
             // Heartbeat or background tasks would go here

package/dist/config/schemas.js

@@ -1,5 +1,11 @@
 import { z } from 'zod';
 import { DEFAULT_CONFIG } from '../types/config.js';
+export const AudioConfigSchema = z.object({
+    enabled: z.boolean().default(DEFAULT_CONFIG.audio.enabled),
+    apiKey: z.string().optional(),
+    maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
+    supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
@@ -12,6 +18,10 @@ export const ConfigSchema = z.object({
         temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
         api_key: z.string().optional(),
     }).default(DEFAULT_CONFIG.llm),
+    audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
+    memory: z.object({
+        limit: z.number().int().positive().default(DEFAULT_CONFIG.memory.limit),
+    }).default(DEFAULT_CONFIG.memory),
     channels: z.object({
         telegram: z.object({
             enabled: z.boolean().default(false),

package/dist/runtime/__tests__/agent.test.js

@@ -1,12 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Agent } from '../agent.js';
 import { ProviderFactory } from '../providers/factory.js';
+import { ToolsFactory } from '../tools/factory.js';
 import { DEFAULT_CONFIG } from '../../types/config.js';
 import { AIMessage } from '@langchain/core/messages';
 import * as fs from 'fs-extra';
 import * as path from 'path';
 import { homedir } from 'os';
 vi.mock('../providers/factory.js');
+vi.mock('../tools/factory.js');
 describe('Agent', () => {
     let agent;
     const mockProvider = {
@@ -27,8 +29,9 @@ describe('Agent', () => {
                 // Ignore errors if database doesn't exist or is corrupted
             }
         }
-        mockProvider.invoke.mockResolvedValue(new AIMessage('Hello world'));
-        vi.mocked(ProviderFactory.create).mockReturnValue(mockProvider);
+        mockProvider.invoke.mockResolvedValue({ messages: [new AIMessage('Hello world')] });
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
+        vi.mocked(ToolsFactory.create).mockResolvedValue([]);
         agent = new Agent(DEFAULT_CONFIG);
     });
     afterEach(async () => {
@@ -44,7 +47,8 @@ describe('Agent', () => {
     });
     it('should initialize successfully', async () => {
         await agent.initialize();
-        expect(ProviderFactory.create).toHaveBeenCalledWith(DEFAULT_CONFIG.llm);
+        expect(ToolsFactory.create).toHaveBeenCalled();
+        expect(ProviderFactory.create).toHaveBeenCalledWith(DEFAULT_CONFIG.llm, []);
     });
     it('should chat successfully', async () => {
         await agent.initialize();
@@ -67,7 +71,7 @@ describe('Agent', () => {
         expect(history1[1].content).toBe('Hello world'); // AI
         // Second turn
         // Update mock return value for next call
-        mockProvider.invoke.mockResolvedValue(new AIMessage('I am fine'));
+        mockProvider.invoke.mockResolvedValue({ messages: [new AIMessage('I am fine')] });
         await agent.chat('How are you?');
         const history2 = await agent.getHistory();
         expect(history2).toHaveLength(4);

package/dist/runtime/__tests__/agent_memory_limit.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Agent } from '../agent.js';
+import { ProviderFactory } from '../providers/factory.js';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+import { AIMessage } from '@langchain/core/messages';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { homedir } from 'os';
+vi.mock('../providers/factory.js');
+describe('Agent Memory Limit', () => {
+    let agent;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Clean up DB
+        if (fs.existsSync(dbPath)) {
+            try {
+                const Database = (await import("better-sqlite3")).default;
+                const db = new Database(dbPath);
+                db.exec("DELETE FROM messages");
+                db.close();
+            }
+            catch (err) { }
+        }
+        mockProvider.invoke.mockResolvedValue({
+            messages: [new AIMessage('Response')]
+        });
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
+    });
+    afterEach(async () => {
+        if (agent) {
+            try {
+                await agent.clearMemory();
+            }
+            catch (err) { }
+        }
+    });
+    it('should respect configured memory limit', async () => {
+        const limitedConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+        limitedConfig.memory.limit = 2; // Only last 2 messages (1 exchange)
+        agent = new Agent(limitedConfig);
+        await agent.initialize();
+        // Turn 1
+        await agent.chat('Msg 1');
+        // Turn 2
+        await agent.chat('Msg 2');
+        // Turn 3
+        await agent.chat('Msg 3');
+        // DB should have 6 messages (3 User + 3 AI)
+        // getHistory() should return only 2 (User Msg 3 + AI Response)
+        // Wait, SQLiteChatMessageHistory limit might be total messages? Or pairs?
+        // LangChain's limit usually means "last N messages".
+        const history = await agent.getHistory();
+        // Assuming limit=2 means 2 messages.
+        expect(history.length).toBeLessThanOrEqual(2);
+        expect(history[history.length - 1].content).toBe('Response');
+    });
+});

package/dist/runtime/__tests__/agent_persistence.test.js

@@ -35,7 +35,7 @@ describe("Agent Persistence Integration", () => {
         // Mock the SQLiteChatMessageHistory to use test path
         // We'll use the default ~/.morpheus path for this test
         mockProvider.invoke.mockResolvedValue(new AIMessage("Test response"));
-        vi.mocked(ProviderFactory.create).mockReturnValue(mockProvider);
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
         agent = new Agent(DEFAULT_CONFIG);
     });
     afterEach(async () => {

package/dist/runtime/__tests__/manual_start_verify.js

@@ -10,7 +10,15 @@ const mockConfig = {
         discord: { enabled: false }
     },
     ui: { enabled: false, port: 3333 },
-    logging: { enabled: false, level: 'info', retention: '1d' }
+    logging: { enabled: false, level: 'info', retention: '1d' },
+    audio: {
+        enabled: false,
+        maxDurationSeconds: 60,
+        supportedMimeTypes: ['audio/ogg']
+    },
+    memory: {
+        limit: 100
+    }
 };
 const run = async () => {
     try {

package/dist/runtime/agent.js

@@ -1,5 +1,6 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
 import { ProviderFactory } from "./providers/factory.js";
+import { ToolsFactory } from "./tools/factory.js";
 import { ConfigManager } from "../config/manager.js";
 import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
@@ -23,13 +24,15 @@ export class Agent {
         // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
         // to allow for Environment Variable fallback supported by LangChain.
         try {
-            this.provider = ProviderFactory.create(this.config.llm);
+            const tools = await ToolsFactory.create();
+            this.provider = await ProviderFactory.create(this.config.llm, tools);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
             // Initialize persistent memory with SQLite
             this.history = new SQLiteChatMessageHistory({
                 sessionId: "default",
+                limit: this.config.memory?.limit || 100, // Fallback purely defensive if config type allows optional
             });
         }
         catch (err) {
@@ -57,13 +60,13 @@ export class Agent {
                 ...previousMessages,
                 userMessage
             ];
-            const response = await this.provider.invoke(messages);
-            const content = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+            const response = await this.provider.invoke({ messages });
+            // console.log('Agent response:', response);
             // Persist messages to database
             await this.history.addMessage(userMessage);
-            await this.history.addMessage(new AIMessage(content));
+            await this.history.addMessage(new AIMessage(response.messages[response.messages.length - 1].text));
             this.display.log('Response generated.', { source: 'Agent' });
-            return content;
+            return response.messages[response.messages.length - 1].text;
         }
         catch (err) {
             throw new ProviderError(this.config.llm.provider, err, "Chat request failed");

package/dist/runtime/audio-agent.js

@@ -0,0 +1,45 @@
+import { GoogleGenAI } from '@google/genai';
+export class AudioAgent {
+    async transcribe(filePath, mimeType, apiKey) {
+        try {
+            const ai = new GoogleGenAI({ apiKey });
+            // Upload the file
+            const uploadResult = await ai.files.upload({
+                file: filePath,
+                config: { mimeType }
+            });
+            // Generate content (transcription)
+            // using gemini-1.5-flash as it is fast and supports audio
+            const response = await ai.models.generateContent({
+                model: 'gemini-2.5-flash-lite',
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                fileData: {
+                                    fileUri: uploadResult.uri,
+                                    mimeType: uploadResult.mimeType
+                                }
+                            },
+                            { text: "Transcribe this audio message accurately. Return only the transcribed text without any additional commentary." }
+                        ]
+                    }
+                ]
+            });
+            // The new SDK returns text directly on the response object
+            const text = response.text;
+            if (!text) {
+                throw new Error('No transcription generated');
+            }
+            return text;
+        }
+        catch (error) {
+            // Wrap error for clarity
+            if (error instanceof Error) {
+                throw new Error(`Audio transcription failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+}

package/dist/runtime/display.js

@@ -80,6 +80,9 @@ export class DisplayManager {
             else if (options.source === 'Agent') {
                 color = chalk.hex('#FFA500');
             }
+            else if (options.source === 'AgentAudio') {
+                color = chalk.hex('#b902b9');
+            }
             prefix = color(`[${options.source}] `);
         }
         let formattedMessage = message;

package/dist/runtime/memory/sqlite.js

@@ -8,9 +8,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     lc_namespace = ["langchain", "stores", "message", "sqlite"];
     db;
     sessionId;
+    limit;
     constructor(fields) {
         super();
         this.sessionId = fields.sessionId;
+        this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
         const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
         // Ensure the directory exists
@@ -97,8 +99,9 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async getMessages() {
         try {
-            const stmt = this.db.prepare("SELECT type, content FROM messages WHERE session_id = ? ORDER BY id ASC");
-            const rows = stmt.all(this.sessionId);
+            // Esta query é válida para SQLite: seleciona os campos type e content da tabela messages filtrando por session_id, ordenando por id e limitando o número de resultados.
+            const stmt = this.db.prepare("SELECT type, content FROM messages WHERE session_id = ? ORDER BY id ASC LIMIT ?");
+            const rows = stmt.all(this.sessionId, this.limit);
             return rows.map((row) => {
                 switch (row.type) {
                     case "human":

package/dist/runtime/providers/factory.js

@@ -3,38 +3,57 @@ import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOllama } from "@langchain/ollama";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ProviderError } from "../errors.js";
+import { createAgent } from "langchain";
+// import { MultiServerMCPClient, } from "@langchain/mcp-adapters"; // REMOVED
+import { z } from "zod";
+import { DisplayManager } from "../display.js";
 export class ProviderFactory {
-    static create(config) {
+    static async create(config, tools = []) {
+        let display = DisplayManager.getInstance();
+        let model;
+        const responseSchema = z.object({
+            content: z.string().describe("The main response content from the agent"),
+        });
+        // Removed direct MCP client instantiation
         try {
             switch (config.provider) {
                 case 'openai':
-                    return new ChatOpenAI({
+                    model = new ChatOpenAI({
                         modelName: config.model,
                         temperature: config.temperature,
                         apiKey: config.api_key, // LangChain will also check process.env.OPENAI_API_KEY
                     });
+                    break;
                 case 'anthropic':
-                    return new ChatAnthropic({
+                    model = new ChatAnthropic({
                         modelName: config.model,
                         temperature: config.temperature,
                         apiKey: config.api_key,
                     });
+                    break;
                 case 'ollama':
                     // Ollama usually runs locally, api_key optional
-                    return new ChatOllama({
+                    model = new ChatOllama({
                         model: config.model,
                         temperature: config.temperature,
                         baseUrl: config.api_key, // Sometimes users might overload api_key for base URL or similar, but simplified here
                     });
+                    break;
                 case 'gemini':
-                    return new ChatGoogleGenerativeAI({
+                    model = new ChatGoogleGenerativeAI({
                         model: config.model,
                         temperature: config.temperature,
-                        apiKey: config.api_key,
+                        apiKey: config.api_key
                     });
+                    break;
                 default:
                     throw new Error(`Unsupported provider: ${config.provider}`);
             }
+            const toolsForAgent = tools;
+            return createAgent({
+                model: model,
+                tools: toolsForAgent,
+            });
         }
         catch (error) {
             let suggestion = "Check your configuration and API keys.";