@tyvm/knowhow 0.0.33 → 0.0.35

package/ts_build/src/chat/modules/AgentModule.js

@@ -0,0 +1,709 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentModule = void 0;
+const KnowhowClient_1 = require("../../services/KnowhowClient");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chat_1 = require("../../chat");
+const BaseChatModule_1 = require("./BaseChatModule");
+const index_1 = require("../../utils/index");
+const TokenCompressor_1 = require("../../processors/TokenCompressor");
+const ToolResponseCache_1 = require("../../processors/ToolResponseCache");
+const index_2 = require("../../processors/index");
+const agents_1 = require("../../agents");
+class AgentModule extends BaseChatModule_1.BaseChatModule {
+    name = "agent";
+    description = "Agent interaction functionality";
+    taskRegistry = new Map();
+    sessionsDir = "./.knowhow/chats/sessions";
+    constructor() {
+        super();
+        if (!fs.existsSync(this.sessionsDir)) {
+            fs.mkdirSync(this.sessionsDir, { recursive: true });
+        }
+    }
+    getCommands() {
+        return [
+            {
+                name: "agent",
+                description: "Start an agent by name",
+                handler: this.handleAgentCommand.bind(this),
+            },
+            {
+                name: "agents",
+                description: "List available agents",
+                handler: this.handleAgentsCommand.bind(this),
+            },
+            {
+                name: "attach",
+                description: "Attach to a running session or resume an old session",
+                handler: this.handleAttachCommand.bind(this),
+            },
+            {
+                name: "sessions",
+                description: "List active tasks and saved sessions",
+                handler: this.handleSessionsCommand.bind(this),
+            },
+        ];
+    }
+    getModes() {
+        return [
+            {
+                name: "agent",
+                description: "Agent interaction mode",
+                active: true,
+            },
+        ];
+    }
+    async initialize(service) {
+        await super.initialize(service);
+        await this.handleAgentCommand(["Patcher"]);
+    }
+    async handleAgentCommand(args) {
+        const context = this.chatService?.getContext();
+        if (args.length === 0) {
+            if (context?.agentMode) {
+                if (context) {
+                    context.agentMode = false;
+                    context.selectedAgent = undefined;
+                    context.currentAgent = undefined;
+                }
+                console.log("Agent mode disabled. Switched to chat mode.");
+                return;
+            }
+            else {
+                console.log("Agent mode is currently disabled. Use /agent <agent_name> to enable it, or /agents to list available agents.");
+                return;
+            }
+        }
+        const agentName = args[0];
+        const allAgents = (0, agents_1.agents)();
+        try {
+            if (allAgents && allAgents[agentName]) {
+                if (context) {
+                    context.selectedAgent = allAgents[agentName];
+                    context.agentMode = true;
+                    context.currentAgent = agentName;
+                }
+                console.log(`Agent mode enabled. Selected agent: ${agentName}. Type your task to get started.`);
+            }
+            else {
+                console.log(`Agent "${agentName}" not found. Use /agents to list available agents.`);
+            }
+        }
+        catch (error) {
+            console.error(`Error selecting agent ${agentName}:`, error);
+        }
+    }
+    async handleAttachCommand(args) {
+        if (args.length === 0) {
+            const runningTasks = Array.from(this.taskRegistry.values());
+            const savedSessions = await this.listAvailableSessions();
+            if (runningTasks.length === 0 && savedSessions.length === 0) {
+                console.log("No active tasks or saved sessions found to attach to.");
+                return;
+            }
+            console.log("\n📋 Available Sessions & Tasks:");
+            console.log("─".repeat(80));
+            console.log("ID".padEnd(25) + "Agent".padEnd(15) + "Status".padEnd(12) + "Type");
+            console.log("─".repeat(80));
+            savedSessions.forEach((session) => {
+                console.log(session.sessionId.padEnd(25) +
+                    session.agentName.padEnd(15) +
+                    session.status.padEnd(12) +
+                    "saved");
+            });
+            runningTasks.forEach((task) => {
+                console.log(task.taskId.padEnd(25) +
+                    task.agentName.padEnd(15) +
+                    task.status.padEnd(12) +
+                    "running");
+            });
+            console.log("─".repeat(80));
+            const allIds = [
+                ...savedSessions.map((s) => s.sessionId),
+                ...runningTasks.map((t) => t.taskId),
+            ];
+            const selectedId = await this.chatService?.getInput("Select a session/task to attach to (or press Enter to skip): ", allIds);
+            if (selectedId &&
+                selectedId.trim() &&
+                allIds.includes(selectedId.trim())) {
+                await this.handleAttachById(selectedId.trim());
+            }
+            return;
+        }
+        const taskId = args[0];
+        await this.handleAttachById(taskId);
+    }
+    displaySingleTask(task) {
+        console.log(`\n📋 Task Details: ${task.taskId}`);
+        console.log("─".repeat(50));
+        console.log(`Agent: ${task.agentName}`);
+        console.log(`Status: ${task.status}`);
+        console.log(`Initial Input: ${task.initialInput}`);
+        console.log(`Start Time: ${new Date(task.startTime).toLocaleString()}`);
+        if (task.endTime) {
+            console.log(`End Time: ${new Date(task.endTime).toLocaleString()}`);
+            console.log(`Duration: ${Math.round((task.endTime - task.startTime) / 1000)}s`);
+        }
+        else {
+            console.log(`Running for: ${Math.round((Date.now() - task.startTime) / 1000)}s`);
+        }
+        console.log(`Total Cost: $${task.totalCost.toFixed(3)}`);
+        console.log("─".repeat(50));
+    }
+    async handleAgentsCommand(args) {
+        try {
+            const allAgents = (0, agents_1.agents)();
+            if (allAgents && Object.keys(allAgents).length > 0) {
+                const agentNames = Object.keys(allAgents);
+                console.log("\nAvailable agents:");
+                Object.entries(allAgents).forEach(([name, agent]) => {
+                    console.log(`  - ${name}: ${agent.description || "No description"}`);
+                });
+                console.log("─".repeat(80), "\n");
+                const selectedAgent = await this.chatService?.getInput("Select an agent to start: ", agentNames);
+                if (selectedAgent &&
+                    selectedAgent.trim() &&
+                    agentNames.includes(selectedAgent.trim())) {
+                    await this.handleAgentCommand([selectedAgent.trim()]);
+                }
+                else if (selectedAgent && selectedAgent.trim()) {
+                    console.log(`Agent "${selectedAgent.trim()}" not found.`);
+                }
+            }
+            else {
+                console.log("No agents available.");
+            }
+        }
+        catch (error) {
+            console.error("Error listing agents:", error);
+            console.log("Could not load agents list.");
+        }
+    }
+    async logSessionTable() {
+        const runningTasks = Array.from(this.taskRegistry.values());
+        const savedSessions = await this.listAvailableSessions();
+        console.log("\n📋 Sessions & Tasks:");
+        const data = [];
+        savedSessions.forEach((session) => {
+            const lastUpdated = new Date(session.lastUpdated).toLocaleString();
+            const inputPreview = session.initialInput && session.initialInput.length > 30
+                ? session.initialInput.substring(0, 27) + "..."
+                : session.initialInput || "[No input]";
+            const cost = session.totalCost
+                ? `$${session.totalCost.toFixed(3)}`
+                : "$0.000";
+            data.push({
+                ID: session.sessionId,
+                Agent: session.agentName,
+                Status: session.status,
+                Type: "saved",
+                Time: lastUpdated,
+                Cost: cost,
+                "Initial Input": inputPreview,
+            });
+        });
+        runningTasks.forEach((task) => {
+            const elapsed = task.endTime
+                ? `${Math.round((task.endTime - task.startTime) / 1000)}s`
+                : `${Math.round((Date.now() - task.startTime) / 1000)}s`;
+            const cost = `$${task.totalCost.toFixed(3)}`;
+            const inputPreview = task.initialInput.length > 30
+                ? task.initialInput.substring(0, 27) + "..."
+                : task.initialInput;
+            data.push({
+                ID: task.taskId,
+                Agent: task.agentName,
+                Status: task.status,
+                Type: "running",
+                Time: elapsed,
+                Cost: cost,
+                "Initial Input": inputPreview,
+            });
+        });
+        console.table(data);
+    }
+    async handleSessionsCommand(args) {
+        try {
+            const runningTasks = Array.from(this.taskRegistry.values());
+            const savedSessions = await this.listAvailableSessions();
+            if (runningTasks.length === 0 && savedSessions.length === 0) {
+                console.log("No active tasks or saved sessions found.");
+                return;
+            }
+            await this.logSessionTable();
+            const allIds = [
+                ...savedSessions.map((s) => s.sessionId),
+                ...runningTasks.map((t) => t.taskId),
+            ];
+            if (allIds.length > 0) {
+                const selectedId = await this.chatService?.getInput("Select a session/task to attach to (or press Enter to skip): ", allIds);
+                if (selectedId &&
+                    selectedId.trim() &&
+                    allIds.includes(selectedId.trim())) {
+                    await this.handleAttachById(selectedId.trim());
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error listing sessions and tasks:", error);
+        }
+    }
+    async handleAttachById(id) {
+        if (this.taskRegistry.has(id)) {
+            const taskInfo = this.taskRegistry.get(id);
+            if (taskInfo) {
+                const context = this.chatService?.getContext();
+                const allAgents = (0, agents_1.agents)();
+                const selectedAgent = allAgents[taskInfo.agentName];
+                if (context && selectedAgent) {
+                    context.selectedAgent = selectedAgent;
+                    context.agentMode = true;
+                    context.currentAgent = taskInfo.agentName;
+                    console.log(`🔄 Switched to agent mode with ${taskInfo.agentName}`);
+                    console.log(`📋 Attached to running task: ${id}`);
+                    console.log(`Task: ${taskInfo.initialInput}`);
+                    console.log(`Status: ${taskInfo.status}`);
+                    return;
+                }
+            }
+            console.log(index_1.Marked.parse(`**Attached to running task: ${id}**`));
+            return;
+        }
+        try {
+            const sessionPath = path.join(this.sessionsDir, `${id}.json`);
+            if (fs.existsSync(sessionPath)) {
+                console.log(index_1.Marked.parse(`**Resuming saved session: ${id}**`));
+                const content = fs.readFileSync(sessionPath, "utf-8");
+                const session = JSON.parse(content);
+                const context = this.chatService?.getContext();
+                const allAgents = (0, agents_1.agents)();
+                const selectedAgent = allAgents[session.agentName];
+                if (context && selectedAgent) {
+                    context.selectedAgent = selectedAgent;
+                    context.agentMode = true;
+                    console.log(`🔄 Switched to agent mode with ${session.agentName}`);
+                    console.log(`📋 Resuming saved session: ${id}`);
+                    console.log(`Original task: ${session.initialInput}`);
+                    console.log(`Status: ${session.status}`);
+                    const addedContext = await this.chatService.getInput("Add any additional context for resuming this session (or press Enter to skip): ");
+                    await this.resumeSession(id);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+        }
+        console.log(index_1.Marked.parse(`**Session/Task ${id} not found.**`));
+    }
+    async listAvailableSessions() {
+        try {
+            const files = fs.readdirSync(this.sessionsDir);
+            const sessionFiles = files.filter((f) => f.endsWith(".json"));
+            const sessions = [];
+            const thresholdTime = 15 * 60 * 1000;
+            for (const file of sessionFiles) {
+                const filePath = path.join(this.sessionsDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf8");
+                    const session = JSON.parse(content);
+                    const isStale = Date.now() - session.lastUpdated > thresholdTime;
+                    const isRunningAndNotInRegistry = session.status === "running" &&
+                        !this.taskRegistry.has(session.sessionId);
+                    if (isRunningAndNotInRegistry && isStale) {
+                        console.log(`🧹 Marking stale session ${session.sessionId} as failed (last updated: ${new Date(session.lastUpdated).toLocaleString()})`);
+                        session.status = "failed";
+                        session.lastUpdated = Date.now();
+                        fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+                    }
+                    sessions.push(session);
+                }
+                catch (error) {
+                    console.warn(`Failed to read session file ${file}:`, error.message);
+                }
+            }
+            return sessions.sort((a, b) => b.lastUpdated - a.lastUpdated);
+        }
+        catch (error) {
+            console.warn("Failed to list sessions:", error.message);
+            return [];
+        }
+    }
+    async listSessionsAndTasks() {
+        const runningTasks = Array.from(this.taskRegistry.values());
+        const savedSessions = await this.listAvailableSessions();
+        return {
+            runningTasks,
+            savedSessions,
+        };
+    }
+    getTaskRegistry() {
+        return this.taskRegistry;
+    }
+    async resumeSession(sessionId, resumeReason) {
+        try {
+            const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+            const content = fs.readFileSync(sessionPath, "utf-8");
+            const session = JSON.parse(content);
+            const lastThread = session.threads[session.threads.length - 1];
+            console.log(`\n🔄 Resuming session: ${sessionId}`);
+            console.log(`Agent: ${session.agentName}`);
+            console.log(`Original task: ${session.initialInput}`);
+            console.log(`Status: ${session.status}`);
+            const reason = resumeReason
+                ? `Reason for resuming:  ${resumeReason}`
+                : "";
+            const resumePrompt = `You are resuming a previously started task. Here's the context:
+ORIGINAL REQUEST:
+${session.initialInput}
+
+LAST Progress State:
+${JSON.stringify(lastThread)}
+
+Please continue from where you left off and complete the original request.
+${reason}
+
+`;
+            console.log("🚀 Session resumption would restart the agent here...");
+            const context = this.chatService?.getContext() || {};
+            const allAgents = (0, agents_1.agents)();
+            const selectedAgent = allAgents[session.agentName] || allAgents[context.currentAgent];
+            if (!selectedAgent) {
+                console.error(`Agent ${session.agentName} not found.`);
+                return;
+            }
+            const { agent, taskId } = await this.setupAgent({
+                agentName: selectedAgent.name,
+                input: resumePrompt,
+                messageId: session.knowhowMessageId,
+                existingKnowhowTaskId: session.knowhowTaskId,
+                chatHistory: [],
+                run: true,
+            });
+            await this.attachedAgentChatLoop(taskId, agent);
+        }
+        catch (error) {
+            console.error(`Failed to resume session ${sessionId}:`, error.message);
+        }
+    }
+    async handleInput(input, context) {
+        if (context.agentMode && context.selectedAgent) {
+            const result = await this.startAgent(context.selectedAgent, input, context.chatHistory || []);
+            return result;
+        }
+        return false;
+    }
+    async setupAgent(options) {
+        const allAgents = (0, agents_1.agents)();
+        if (!allAgents[options.agentName]) {
+            throw new Error(`Agent "${options.agentName}" not found. Available agents: ${Object.keys(allAgents).join(", ")}`);
+        }
+        const { input, chatHistory = [], agentName } = options;
+        const agent = allAgents[options.agentName];
+        let done = false;
+        let output = "Done";
+        const taskId = this.generateTaskId(input);
+        let knowhowTaskId;
+        try {
+            let taskInfo = {
+                taskId,
+                knowhowMessageId: options.messageId,
+                knowhowTaskId: options.existingKnowhowTaskId,
+                agentName,
+                agent,
+                initialInput: input,
+                status: "running",
+                startTime: Date.now(),
+                totalCost: 0,
+            };
+            this.taskRegistry.set(taskId, taskInfo);
+            this.saveSession(taskId, taskInfo, []);
+            const baseUrl = process.env.KNOWHOW_API_URL;
+            console.log(`Base URL for Knowhow API: ${baseUrl}, Message ID: ${options.messageId}`);
+            const client = new KnowhowClient_1.KnowhowSimpleClient(baseUrl);
+            if (options.messageId && !options.existingKnowhowTaskId && baseUrl) {
+                try {
+                    const response = await client.createChatTask({
+                        messageId: options.messageId,
+                        prompt: input,
+                    });
+                    knowhowTaskId = response.data.id;
+                    console.log(`✅ Created Knowhow chat task: ${knowhowTaskId}`);
+                    taskInfo.knowhowTaskId = knowhowTaskId;
+                    this.taskRegistry.set(taskId, taskInfo);
+                }
+                catch (error) {
+                    console.error(`❌ Failed to create Knowhow chat task:`, error);
+                }
+            }
+            agent.agentEvents.on("threadUpdate", async (threadState) => {
+                taskInfo.totalCost = agent.getTotalCostUsd();
+                this.updateSession(taskId, threadState);
+                if (knowhowTaskId && options.messageId && baseUrl) {
+                    await client
+                        .updateChatTask(knowhowTaskId, {
+                        threads: agent.getThreads(),
+                        totalCostUsd: agent.getTotalCostUsd(),
+                        inProgress: true,
+                    })
+                        .catch((error) => {
+                        console.error(`❌ Failed to update Knowhow chat task:`, error);
+                    });
+                    console.log(`✅ Updated Knowhow chat task: ${knowhowTaskId}`);
+                }
+            });
+            console.log(index_1.Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`));
+            console.log(index_1.Marked.parse(`**Task:** ${input}`));
+            await agent.newTask();
+            const context = this.chatService?.getContext();
+            const plugins = context?.plugins || [];
+            const formattedPrompt = await (0, chat_1.formatChatInput)(input, plugins, chatHistory);
+            agent.messageProcessor.setProcessors("pre_call", [
+                new ToolResponseCache_1.ToolResponseCache(agent.tools).createProcessor(),
+                new TokenCompressor_1.TokenCompressor(agent.tools).createProcessor((msg) => Boolean(msg.role === "tool" && msg.tool_call_id)),
+                new index_2.CustomVariables(agent.tools).createProcessor(),
+            ]);
+            agent.messageProcessor.setProcessors("post_call", [
+                new index_2.XmlToolCallProcessor().createProcessor(),
+                new index_2.HarmonyToolProcessor().createProcessor(),
+            ]);
+            if (!agent.agentEvents.listenerCount(agent.eventTypes.toolUsed)) {
+                agent.agentEvents.on(agent.eventTypes.toolUsed, (responseMsg) => {
+                    console.log(` 🔨 Tool used: ${JSON.stringify(responseMsg, null, 2)}`);
+                });
+            }
+            const taskCompleted = new Promise((resolve) => {
+                agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
+                    console.log("Agent has finished.");
+                    done = true;
+                    output = doneMsg || "No response from the AI";
+                    taskInfo = this.taskRegistry.get(taskId);
+                    if (taskInfo) {
+                        taskInfo.status = "completed";
+                        taskInfo.totalCost = agent.getTotalCostUsd();
+                        this.updateSession(taskId, agent.getThreads());
+                        taskInfo.endTime = Date.now();
+                        if (knowhowTaskId && options.messageId) {
+                            console.log(`Updating Knowhow chat task on completion..., ${knowhowTaskId}, ${options.messageId}`);
+                            await client
+                                .updateChatTask(knowhowTaskId, {
+                                inProgress: false,
+                                threads: agent.getThreads(),
+                                totalCostUsd: agent.getTotalCostUsd(),
+                                result: output,
+                            })
+                                .catch((error) => {
+                                console.error(`❌ Failed to update Knowhow chat task on completion:`, error);
+                            });
+                            console.log(`✅ Completed Knowhow chat task: ${knowhowTaskId}`);
+                        }
+                    }
+                    console.log(index_1.Marked.parse(output));
+                    resolve(doneMsg);
+                });
+            });
+            if (options.maxTimeLimit) {
+                agent.setMaxRunTime(options.maxTimeLimit * 60 * 1000);
+            }
+            console.log(`🤖 Starting agent: ${options.agentName}`);
+            console.log(`📝 Task: ${options.input}`);
+            if (options.maxTimeLimit) {
+                console.log(`⏱️  Time limit: ${options.maxTimeLimit} minutes`);
+            }
+            if (options.maxSpendLimit) {
+                console.log(`💰 Spend limit: $${options.maxSpendLimit}`);
+            }
+            console.log("─".repeat(50));
+            if (options.run) {
+                agent.call(formattedPrompt);
+            }
+            return { agent, taskId, formattedPrompt, taskCompleted };
+        }
+        catch (error) {
+            console.error("Agent setup failed:", error);
+            this.taskRegistry.delete(taskId);
+        }
+    }
+    getActiveTasks() {
+        return Array.from(this.taskRegistry.entries()).map(([taskId, taskInfo]) => ({
+            taskId,
+            agent: taskInfo,
+        }));
+    }
+    attachToTask(taskId) {
+        if (this.taskRegistry.has(taskId)) {
+            console.log(index_1.Marked.parse(`**Attached to agent task: ${taskId}**`));
+            return true;
+        }
+        console.log(index_1.Marked.parse(`**Task ${taskId} not found or already completed.**`));
+        return false;
+    }
+    generateTaskId(initialInput) {
+        const words = initialInput
+            .toLowerCase()
+            .replace(/[^\w\s]/g, "")
+            .split(/\s+/)
+            .filter((word) => word.length > 2)
+            .slice(0, 3);
+        const wordPart = words.join("-") || "task";
+        const timestamp = Date.now().toString().slice(-6);
+        return `${wordPart}-${timestamp}`;
+    }
+    saveSession(taskId, taskInfo, threads) {
+        try {
+            const sessionPath = path.join(this.sessionsDir, `${taskId}.json`);
+            const session = {
+                sessionId: taskId,
+                knowhowMessageId: taskInfo.knowhowMessageId,
+                knowhowTaskId: taskInfo.knowhowTaskId,
+                taskId,
+                agentName: taskInfo.agentName,
+                initialInput: taskInfo.initialInput,
+                status: taskInfo.status,
+                startTime: taskInfo.startTime,
+                endTime: taskInfo.endTime,
+                totalCost: taskInfo.totalCost,
+                threads,
+                currentThread: 0,
+                lastUpdated: Date.now(),
+            };
+            fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+        }
+        catch (error) {
+            console.error(`Error saving session ${taskId}:`, error);
+        }
+    }
+    updateSession(taskId, threads) {
+        try {
+            const sessionPath = path.join(this.sessionsDir, `${taskId}.json`);
+            if (fs.existsSync(sessionPath)) {
+                const session = JSON.parse(fs.readFileSync(sessionPath, "utf8"));
+                const taskInfo = this.taskRegistry.get(taskId);
+                session.threads = threads;
+                session.lastUpdated = Date.now();
+                if (taskInfo) {
+                    session.status = taskInfo.status;
+                    session.endTime = taskInfo.endTime;
+                    session.totalCost = taskInfo.totalCost;
+                    session.knowhowMessageId = taskInfo.knowhowMessageId;
+                    session.knowhowTaskId = taskInfo.knowhowTaskId;
+                }
+                fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+            }
+        }
+        catch (error) {
+            console.error(`Error updating session ${taskId}:`, error);
+        }
+    }
+    async startAgent(selectedAgent, initialInput, chatHistory = []) {
+        try {
+            const { agent, taskId } = await this.setupAgent({
+                agentName: selectedAgent.name,
+                input: initialInput,
+                chatHistory,
+                run: true,
+            });
+            return await this.attachedAgentChatLoop(taskId, agent);
+        }
+        catch (error) {
+            console.error("Error starting agent:", error);
+            return false;
+        }
+    }
+    async attachedAgentChatLoop(taskId, agent) {
+        try {
+            let done = false;
+            let output = "Done";
+            const commands = ["pause", "unpause", "kill", "detach"];
+            const history = [];
+            let input = (await this.chatService?.getInput(`Enter command or message for ${agent.name}: `, commands)) || "";
+            history.push(input);
+            let finished = false;
+            const donePromise = new Promise((resolve) => {
+                agent.agentEvents.once(agent.eventTypes.done, (doneMsg) => {
+                    console.log("Agent has completed the task.");
+                    finished = true;
+                    resolve("done");
+                });
+            });
+            while (!done) {
+                switch (input) {
+                    case "":
+                        if (finished) {
+                            output = "Agent has completed the task.";
+                            done = true;
+                        }
+                        break;
+                    case "done":
+                        output = "Exited agent interaction.";
+                        done = true;
+                        break;
+                    case "pause":
+                        await agent.pause();
+                        console.log("Agent paused.");
+                        break;
+                    case "unpause":
+                        await agent.unpause();
+                        console.log("Agent unpaused.");
+                        break;
+                    case "kill":
+                        await agent.kill();
+                        console.log("Agent terminated.");
+                        done = true;
+                        break;
+                    case "detach":
+                        console.log("Detached from agent");
+                        return true;
+                    default:
+                        agent.addPendingUserMessage({
+                            role: "user",
+                            content: input,
+                        });
+                }
+                if (!done) {
+                    input = await this.chatService?.getInput(`Enter command or message for ${agent.name}: `, commands);
+                }
+            }
+            const finalTaskInfo = this.taskRegistry.get(taskId);
+            if (finalTaskInfo) {
+                if (finalTaskInfo.status === "running") {
+                    finalTaskInfo.status = "completed";
+                    finalTaskInfo.totalCost = agent.getTotalCostUsd();
+                    finalTaskInfo.endTime = Date.now();
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.error("Agent execution failed:", error);
+            this.taskRegistry.delete(taskId);
+            return false;
+        }
+    }
+}
+exports.AgentModule = AgentModule;
+//# sourceMappingURL=AgentModule.js.map