@tyvm/knowhow 0.0.83 → 0.0.85

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

@@ -24,30 +24,38 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentModule = void 0;
+const renderer_1 = require("../renderer");
 const index_1 = require("../../services/index");
 const fs = __importStar(require("fs"));
 const fsPromises = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const BaseChatModule_1 = require("./BaseChatModule");
-const index_2 = require("../../utils/index");
+const index_2 = require("../../services/index");
+const index_3 = require("../../utils/index");
 const TokenCompressor_1 = require("../../processors/TokenCompressor");
 const ToolResponseCache_1 = require("../../processors/ToolResponseCache");
-const index_3 = require("../../processors/index");
+const index_4 = require("../../processors/index");
 const agents_1 = require("../../agents");
 const KnowhowClient_1 = require("../../services/KnowhowClient");
 class AgentModule extends BaseChatModule_1.BaseChatModule {
     name = "agent";
     description = "Agent interaction functionality";
+    attachedAgent;
     taskRegistry;
     sessionManager;
-    webSync;
-    fsSync;
+    syncer;
+    processStartTime = Date.now();
+    activeAgentTaskId;
+    activeSyncedWatcher;
+    _wireAgentEvents;
+    _wireTaskId;
+    _wireAgentName;
+    _wireEventTypes;
     constructor() {
         super();
         this.taskRegistry = new index_1.TaskRegistry();
         this.sessionManager = new index_1.SessionManager();
-        this.webSync = new index_1.AgentSyncKnowhowWeb();
-        this.fsSync = new index_1.AgentSyncFs();
+        this.syncer = new index_1.SyncerService();
     }
     getCommands() {
         return [
@@ -62,28 +70,113 @@ class AgentModule extends BaseChatModule_1.BaseChatModule {
                 handler: this.handleAgentsCommand.bind(this),
             },
             {
-                name: "attach",
-                description: "Attach to a running session or resume an old session",
-                handler: this.handleAttachCommand.bind(this),
+                name: "pause",
+                description: "Pause the currently attached agent",
+                modes: ["agent:attached"],
+                handler: async (_args) => {
+                    if (this.attachedAgent) {
+                        await this.attachedAgent.pause();
+                        console.log("Agent paused.");
+                    }
+                },
+            },
+            {
+                name: "unpause",
+                description: "Unpause the currently attached agent",
+                modes: ["agent:attached"],
+                handler: async (_args) => {
+                    if (this.attachedAgent) {
+                        await this.attachedAgent.unpause();
+                        console.log("Agent unpaused.");
+                    }
+                },
             },
             {
-                name: "sessions",
-                description: "List active tasks and saved sessions",
-                handler: this.handleSessionsCommand.bind(this),
+                name: "kill",
+                description: "Kill the currently attached agent",
+                modes: ["agent:attached"],
+                handler: async (_args) => {
+                    if (this.attachedAgent) {
+                        await this.attachedAgent.kill();
+                        console.log("Agent terminated.");
+                        this.detachFromAgent();
+                    }
+                },
+            },
+            {
+                name: "detach",
+                description: "Detach from the currently attached agent",
+                modes: ["agent:attached"],
+                handler: async (_args) => {
+                    console.log("Detached from agent");
+                    this.detachFromAgent();
+                },
+            },
+            {
+                name: "done",
+                description: "Exit the current agent interaction",
+                modes: ["agent:attached"],
+                handler: async (_args) => {
+                    this.detachFromAgent();
+                },
             },
         ];
     }
+    detachFromAgent() {
+        this.attachedAgent = undefined;
+        this.unwireAgentRendering();
+        if (this.chatService) {
+            this.chatService.setMode("default");
+        }
+        if (this.activeSyncedWatcher) {
+            this.activeSyncedWatcher.stopWatching();
+            this.activeSyncedWatcher = undefined;
+        }
+        const context = this.chatService?.getContext();
+        if (context)
+            context.activeAgentTaskId = undefined;
+    }
     getModes() {
         return [
             {
                 name: "agent",
                 description: "Agent interaction mode",
                 active: true,
+                promptText: () => {
+                    const ctx = this.chatService?.getContext();
+                    return ctx?.currentAgent
+                        ? `\nAsk knowhow ${ctx.currentAgent}: `
+                        : `\nAsk knowhow: `;
+                },
+            },
+            {
+                name: "agent:attached",
+                description: "Attached to a running agent",
+                active: false,
+                promptText: () => this.attachedAgent
+                    ? `Enter command or message for ${this.attachedAgent.name}: `
+                    : `Enter command or message for agent: `,
             },
         ];
     }
+    get renderer() {
+        return (this.chatService?.getContext()?.renderer ??
+            new renderer_1.ConsoleRenderer());
+    }
     async initialize(service) {
         await super.initialize(service);
+        const Events = (0, index_2.services)().Events;
+        Events.setListener({ key: "agentModule:pluginLog", event: Events.eventTypes.pluginLog }, (logEvent) => {
+            const activeTasks = this.taskRegistry.getAll();
+            this.renderer.render({
+                type: "log",
+                taskId: this.activeAgentTaskId,
+                agentName: logEvent.source,
+                message: logEvent.message,
+                level: logEvent.level || "info",
+                timestamp: logEvent.timestamp || new Date().toISOString(),
+            });
+        });
         await this.handleAgentCommand(["Patcher"]);
     }
     async handleAgentCommand(args) {
@@ -127,32 +220,76 @@ class AgentModule extends BaseChatModule_1.BaseChatModule {
             console.error(`Error selecting agent ${agentName}:`, error);
         }
     }
-    async handleAttachCommand(args) {
-        if (args.length === 0) {
-            const runningTasks = this.taskRegistry.getAll();
-            const savedSessions = this.sessionManager.listAvailableSessions();
-            if (runningTasks.length === 0 && savedSessions.length === 0) {
-                console.log("No active tasks or saved sessions found to attach to.");
-                return;
-            }
-            await this.sessionManager.logRunningTasks(runningTasks, savedSessions);
-            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;
+    getTaskRegistry() {
+        return this.taskRegistry;
+    }
+    getSessionManager() {
+        return this.sessionManager;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+    getActiveSyncedWatcher() {
+        return this.activeSyncedWatcher;
+    }
+    setActiveSyncedWatcher(w) {
+        this.activeSyncedWatcher = w;
+    }
+    getActiveAgentTaskId() {
+        return this.activeAgentTaskId;
+    }
+    setActiveAgentTaskId(id) {
+        this.activeAgentTaskId = id;
+    }
+    wireAgentRendering(taskId, agentEvents, eventTypes, agentName) {
+        if (eventTypes.toolCall) {
+            agentEvents.setListener({ key: "agentModule:render:toolCall", event: eventTypes.toolCall }, (data) => this.renderer.render({
+                type: "toolCall",
+                taskId,
+                agentName,
+                toolCall: data.toolCall,
+            }));
         }
-        const taskId = args[0];
-        await this.handleAttachById(taskId);
+        if (eventTypes.toolUsed) {
+            agentEvents.setListener({ key: "agentModule:render:toolUsed", event: eventTypes.toolUsed }, (data) => this.renderer.render({
+                type: "toolResult",
+                taskId,
+                agentName,
+                toolCall: data.toolCall,
+                result: data.functionResp,
+            }));
+        }
+        if (eventTypes.agentSay) {
+            agentEvents.setListener({ key: "agentModule:render:agentSay", event: eventTypes.agentSay }, (data) => this.renderer.render({
+                type: "agentMessage",
+                taskId,
+                agentName,
+                message: data.message,
+                role: "assistant",
+            }));
+        }
+        this.activeAgentTaskId = taskId;
+        this.renderer.setActiveTaskId(taskId);
+        this._wireAgentEvents = agentEvents;
+        this._wireAgentName = agentName;
+        this._wireEventTypes = eventTypes;
+        this._wireTaskId = taskId;
     }
-    displaySingleTask(task) {
-        this.taskRegistry.displaySingleTask(task);
+    unwireAgentRendering() {
+        if (this._wireAgentEvents) {
+            this._wireAgentEvents.removeManagedListenersByPrefix("agentModule:render:");
+            this._wireAgentEvents = undefined;
+        }
+        this.activeAgentTaskId = undefined;
+        this.renderer.setActiveTaskId(undefined);
+    }
+    rewireAgentRendering() {
+        if (!this._wireAgentEvents ||
+            !this._wireTaskId ||
+            !this._wireEventTypes ||
+            !this._wireAgentName)
+            return;
+        this.wireAgentRendering(this._wireTaskId, this._wireAgentEvents, this._wireEventTypes, this._wireAgentName);
     }
     async handleAgentsCommand(args) {
         try {
@@ -183,99 +320,8 @@ class AgentModule extends BaseChatModule_1.BaseChatModule {
             console.log("Could not load agents list.");
         }
     }
-    async logSessionTable() {
-        const runningTasks = this.taskRegistry.getAll();
-        const savedSessions = this.sessionManager.listAvailableSessions();
-        this.sessionManager.logSessionTable(runningTasks, savedSessions);
-    }
-    async handleSessionsCommand(args) {
-        try {
-            const runningTasks = this.taskRegistry.getAll();
-            const savedSessions = this.sessionManager.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;
-                    context.currentModel = selectedAgent.getModel();
-                    context.currentProvider = selectedAgent.getProvider();
-                    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_2.Marked.parse(`**Attached to running task: ${id}**`));
-            return;
-        }
-        try {
-            const session = this.sessionManager.loadSession(id);
-            if (session) {
-                console.log(index_2.Marked.parse(`**Resuming saved session: ${id}**`));
-                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;
-                    context.currentModel = selectedAgent.getModel();
-                    context.currentProvider = selectedAgent.getProvider();
-                    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_2.Marked.parse(`**Session/Task ${id} not found.**`));
-    }
-    async listAvailableSessions() {
-        return this.sessionManager.listAvailableSessions();
-    }
-    async listSessionsAndTasks() {
-        const runningTasks = this.taskRegistry.getAll();
-        const savedSessions = this.sessionManager.listAvailableSessions();
-        return {
-            runningTasks,
-            savedSessions,
-        };
-    }
-    getTaskRegistry() {
-        return this.taskRegistry;
+    getProcessStartTime() {
+        return this.processStartTime;
     }
     async resumeSession(sessionId, resumeReason) {
         try {
@@ -327,6 +373,13 @@ Please continue from where you left off and complete the original request.
     }
     async handleInput(input, context) {
         if (context.agentMode && context.selectedAgent) {
+            if (this.attachedAgent) {
+                this.attachedAgent.addPendingUserMessage({
+                    role: "user",
+                    content: input,
+                });
+                return true;
+            }
             const initialInteraction = {
                 input,
                 output: "",
@@ -343,12 +396,12 @@ Please continue from where you left off and complete the original request.
         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(", ")}`);
+        if (!agents_1.agentConstructors[options.agentName]) {
+            throw new Error(`Agent "${options.agentName}" not found. Available agents: ${Object.keys(agents_1.agentConstructors).join(", ")}`);
         }
         const { input, chatHistory = [], agentName } = options;
-        const agent = allAgents[options.agentName];
+        const agentContext = (0, index_2.services)().Agents.getAgentContext();
+        const agent = (0, agents_1.createAgent)(options.agentName, agentContext);
         let done = false;
         let output = "Done";
         const taskId = options.taskId || this.sessionManager.generateTaskId(input);
@@ -371,38 +424,27 @@ Please continue from where you left off and complete the original request.
             };
             this.taskRegistry.register(taskId, taskInfo);
             this.saveSession(taskId, taskInfo, []);
-            this.webSync.reset();
-            this.fsSync.reset();
-            if (options.messageId &&
-                !options.existingKnowhowTaskId &&
-                !options.syncFs) {
-                knowhowTaskId = await this.webSync.createChatTask({
-                    messageId: options.messageId,
-                    prompt: input,
-                });
-                if (knowhowTaskId) {
-                    taskInfo.knowhowTaskId = knowhowTaskId;
-                    this.taskRegistry.register(taskId, taskInfo);
-                    await this.webSync.setupAgentSync(agent, knowhowTaskId);
-                }
-            }
-            else if (!options.messageId || options.syncFs) {
-                console.log(`📁 Using filesystem-based synchronization for task: ${taskId}`);
-                const fsTaskId = await this.fsSync.createTask({
-                    taskId,
-                    prompt: input,
-                });
-                taskInfo.knowhowTaskId = fsTaskId;
-                this.taskRegistry.register(taskId, taskInfo);
-                await this.fsSync.setupAgentSync(agent, fsTaskId);
-            }
+            this.syncer.reset();
+            const syncTaskId = await this.syncer.createTask({
+                taskId,
+                prompt: input,
+                messageId: options.messageId,
+                syncFs: options.syncFs,
+                existingKnowhowTaskId: options.existingKnowhowTaskId,
+                agentName,
+            });
+            const webTaskId = this.syncer.getCreatedWebTaskId();
+            knowhowTaskId = webTaskId;
+            taskInfo.knowhowTaskId = webTaskId || syncTaskId;
+            this.taskRegistry.register(taskId, taskInfo);
+            await this.syncer.setupAgentSync(agent, syncTaskId);
             const threadUpdateHandler = async (threadState) => {
                 this.updateSession(taskId, threadState);
                 taskInfo.totalCost = agent.getTotalCostUsd();
             };
             agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateHandler);
-            console.log(index_2.Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`));
-            console.log(index_2.Marked.parse(`**Task:** ${input}`));
+            console.log(index_3.Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`));
+            console.log(index_3.Marked.parse(`**Task:** ${input}`));
             await agent.newTask(taskId);
             if (options.model) {
                 console.log("Setting model:", options.model);
@@ -418,7 +460,7 @@ Please continue from where you left off and complete the original request.
                     throw new Error("ChatService not available in tools context");
                 }
                 console.log("AI has asked: ");
-                console.log(index_2.Marked.parse(question), "\n");
+                console.log(index_3.Marked.parse(question), "\n");
                 return await chatService.getInput("response: ");
             }, 10);
             const caching = [
@@ -426,53 +468,57 @@ Please continue from where you left off and complete the original request.
                 new TokenCompressor_1.TokenCompressor(agent.tools).createProcessor((msg) => Boolean(msg.role === "tool" && msg.tool_call_id)),
             ];
             agent.messageProcessor.setProcessors("pre_call", [
-                new index_3.Base64ImageProcessor(agent.tools).createProcessor(),
+                new index_4.Base64ImageProcessor(agent.tools).createProcessor(),
                 ...caching,
-                new index_3.CustomVariables(agent.tools).createProcessor(),
+                new index_4.CustomVariables(agent.tools).createProcessor(),
             ]);
             agent.messageProcessor.setProcessors("post_call", [
-                new index_3.XmlToolCallProcessor().createProcessor(),
-                new index_3.HarmonyToolProcessor().createProcessor(),
+                new index_4.XmlToolCallProcessor().createProcessor(),
+                new index_4.HarmonyToolProcessor().createProcessor(),
             ]);
             agent.messageProcessor.setProcessors("post_tools", [
-                new index_3.Base64ImageProcessor(agent.tools).createProcessor(),
+                new index_4.Base64ImageProcessor(agent.tools).createProcessor(),
                 ...caching,
             ]);
-            if (!agent.agentEvents.listenerCount(agent.eventTypes.toolCall)) {
-                agent.agentEvents.on(agent.eventTypes.toolCall, (responseMsg) => {
-                    console.time(JSON.stringify(responseMsg.toolCall.function.name));
-                    console.log(` 🔨 Tool: ${responseMsg.toolCall.function.name}\n Args: ${responseMsg.toolCall.function.arguments}\n`);
+            const agentLogHandler = (logData) => {
+                this.renderer.render({
+                    type: "log",
+                    taskId,
+                    agentName: logData.agentName,
+                    message: logData.message,
+                    level: logData.level,
+                    timestamp: logData.timestamp,
                 });
-            }
-            if (!agent.agentEvents.listenerCount(agent.eventTypes.toolUsed)) {
-                agent.agentEvents.on(agent.eventTypes.toolUsed, (responseMsg) => {
-                    console.timeEnd(JSON.stringify(responseMsg.toolCall.function.name));
-                    console.log(` 🔨 Tool Response:
-              ${JSON.stringify(responseMsg.functionResp, null, 2)}`);
+            };
+            const agentStatusHandler = (statusData) => {
+                this.renderer.render({
+                    type: "agentStatus",
+                    taskId,
+                    agentName: statusData.agentName,
+                    statusMessage: statusData.statusMessage,
+                    details: statusData.details,
+                    timestamp: statusData.timestamp,
                 });
-            }
+            };
+            agent.agentEvents.on(agent.eventTypes.agentLog, agentLogHandler);
+            agent.agentEvents.on(agent.eventTypes.agentStatus, agentStatusHandler);
             const taskCompleted = new Promise((resolve) => {
                 agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
                     console.log("🎯 [AgentModule] Task Completed");
                     done = true;
                     output = doneMsg || "No response from the AI";
                     agent.agentEvents.removeListener(agent.eventTypes.threadUpdate, threadUpdateHandler);
+                    agent.agentEvents.removeListener(agent.eventTypes.agentLog, agentLogHandler);
+                    agent.agentEvents.removeListener(agent.eventTypes.agentStatus, agentStatusHandler);
                     taskInfo = this.taskRegistry.get(taskId);
-                    if (knowhowTaskId) {
-                        console.log("🎯 [AgentModule] Waiting for web sync finalization...");
-                        await this.webSync.waitForFinalization();
-                        console.log("🎯 [AgentModule] Web sync finalization complete");
-                    }
-                    console.log("🎯 [AgentModule] Waiting for fs sync finalization...");
-                    await this.fsSync.waitForFinalization();
-                    console.log("🎯 [AgentModule] Fs sync finalization complete");
+                    await this.syncer.waitForFinalization();
                     if (taskInfo) {
                         taskInfo.status = "completed";
                         taskInfo.totalCost = agent.getTotalCostUsd();
                         this.updateSession(taskId, agent.getThreads());
                         taskInfo.endTime = Date.now();
                     }
-                    console.log(index_2.Marked.parse(output));
+                    console.log(index_3.Marked.parse(output));
                     console.log("🎯 [AgentModule] Task Complete");
                     resolve(doneMsg);
                 });
@@ -589,10 +635,10 @@ Please continue from where you left off and complete the original request.
     }
     attachToTask(taskId) {
         if (this.taskRegistry.has(taskId)) {
-            console.log(index_2.Marked.parse(`**Attached to agent task: ${taskId}**`));
+            console.log(index_3.Marked.parse(`**Attached to agent task: ${taskId}**`));
             return true;
         }
-        console.log(index_2.Marked.parse(`**Task ${taskId} not found or already completed.**`));
+        console.log(index_3.Marked.parse(`**Task ${taskId} not found or already completed.**`));
         return false;
     }
     saveSession(taskId, taskInfo, threads) {
@@ -620,91 +666,35 @@ Please continue from where you left off and complete the original request.
     }
     async attachedAgentChatLoop(taskId, agent, initialInput) {
         try {
-            let done = false;
-            let output = "Done";
             let agentFinalOutput;
             if (this.chatService) {
                 this.chatService.setMode("agent:attached");
             }
-            const modeCommands = this.chatService
-                ?.getCommandsForMode("agent:attached")
-                .map((cmd) => `/${cmd.name}`) || [];
-            const commands = [
-                ...modeCommands,
-                "/pause",
-                "/unpause",
-                "/kill",
-                "/detach",
-                "/done",
-            ];
-            const history = [];
-            let finished = false;
+            this.wireAgentRendering(taskId, agent.agentEvents, agent.eventTypes, agent.name);
+            const context = this.chatService?.getContext();
+            if (context)
+                context.activeAgentTaskId = taskId;
+            this.attachedAgent = agent;
             const donePromise = new Promise((resolve) => {
                 agent.agentEvents.once(agent.eventTypes.done, (doneMsg) => {
                     agentFinalOutput = doneMsg || "No response from the AI";
                     console.log("Finished", taskId, `$${agent.getTotalCostUsd()}`);
-                    finished = true;
+                    const finalTaskInfo = this.taskRegistry.get(taskId);
+                    if (finalTaskInfo) {
+                        if (finalTaskInfo.status === "running") {
+                            finalTaskInfo.status = "completed";
+                            finalTaskInfo.totalCost = agent.getTotalCostUsd();
+                            finalTaskInfo.endTime = Date.now();
+                        }
+                    }
                     resolve("done");
+                    this.detachFromAgent();
                 });
             });
             if (initialInput) {
                 const taskInfo = this.taskRegistry.get(taskId);
                 agent.call(taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput);
             }
-            let input = (await this.chatService?.getInput(`Enter command or message for ${agent.name}: `, commands)) || "";
-            history.push(input);
-            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");
-                        if (this.chatService) {
-                            this.chatService.setMode("default");
-                        }
-                        return { result: true, finalOutput: agentFinalOutput };
-                    default:
-                        agent.addPendingUserMessage({
-                            role: "user",
-                            content: input,
-                        });
-                }
-                if (!done) {
-                    input = await this.chatService?.getInput(`Enter command or message for ${agent.name}: `, commands);
-                }
-            }
-            if (this.chatService) {
-                this.chatService.setMode("default");
-            }
-            const finalTaskInfo = this.taskRegistry.get(taskId);
-            if (finalTaskInfo) {
-                if (finalTaskInfo.status === "running") {
-                    finalTaskInfo.status = "completed";
-                    finalTaskInfo.totalCost = agent.getTotalCostUsd();
-                    finalTaskInfo.endTime = Date.now();
-                }
-            }
             return { result: true, finalOutput: agentFinalOutput };
         }
         catch (error) {