@xalia/agent 0.5.7 → 0.5.8

package/src/test/sudoMcpServerManager.test.ts

@@ -2,51 +2,46 @@ import { expect } from "chai";
 import chalk from "chalk";
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
 
-import { McpServerManager } from "../agent/mcpServerManager";
 import { SkillManager, LOCAL_SERVER_URL } from "../agent/sudoMcpServerManager";
 
-let managers: [McpServerManager, SkillManager] | undefined = undefined;
+let manager: SkillManager | undefined = undefined;
 
-async function getServerManagers(): Promise<[McpServerManager, SkillManager]> {
-  if (!managers) {
-    const tm = new McpServerManager();
-    const sm = await SkillManager.initialize(
-      tm,
+async function getServerManagers(): Promise<SkillManager> {
+  if (!manager) {
+    manager = await SkillManager.initialize(
       (_url: string) => {
         throw "unexpected call to openUrl";
       },
       LOCAL_SERVER_URL,
       "dummy_key"
     );
-
-    managers = [tm, sm];
   }
 
-  return managers;
+  return manager;
 }
 
 async function shutdownAll() {
-  if (managers) {
-    await managers[0].shutdown();
+  if (manager) {
+    await manager.shutdown();
   }
-  managers = undefined;
+  manager = undefined;
 }
 
 describe("SudoMcpServerManager", async () => {
   it("should fetch servers from deployed backend", async () => {
-    const [, sm] = await getServerManagers();
+    const sm = await getServerManagers();
     const serverBriefs = sm.getServerBriefs();
     expect(serverBriefs.length).greaterThan(0);
   }).timeout(10000);
 
   it("should fetch tools for a server", async () => {
-    const [, sm] = await getServerManagers();
+    const sm = await getServerManagers();
     const tools = await sm.getServerTools("sudomcp_simplecalc");
     expect(tools.length).greaterThan(0);
   }).timeout(10000);
 
   it("should add a new MCP server", async () => {
-    const [, sm] = await getServerManagers();
+    const sm = await getServerManagers();
     await sm.addMcpServer("sudomcp_simplecalc", true);
     const serverBriefs = sm.getServerBriefs();
     expect(

package/src/tool/chatMain.ts

@@ -17,7 +17,11 @@ import { getLogger } from "@xalia/xmcp/sdk";
 import { IConversation } from "../agent/agent";
 import { ChatClient } from "../chat/client";
 import { runServer } from "../chat/server";
-import { ClientUserMessage, ServerToClient } from "../chat/messages";
+import {
+  ClientUserMessage,
+  ServerToClient,
+  decodeAssistantMessageParam,
+} from "../chat/messages";
 
 import { IPrompt, Prompt, ScriptPrompt } from "./prompt";
 import * as options from "./options";
@@ -177,7 +181,12 @@ function getCLIOnMessage(): (msg: ServerToClient) => void {
         stdout.write(`[${msg.from}]: ${msg.message}\n`);
         break;
       case "agent_msg":
-        stdout.write(`[AGENT]: ${msg.message}\n`);
+        {
+          const text = decodeAssistantMessageParam(msg.message);
+          if (text) {
+            stdout.write(`[AGENT]: ${text}\n`);
+          }
+        }
         break;
       case "agent_msg_chunk":
         if (startMsg) {

package/src/tool/commandPrompt.ts

@@ -64,12 +64,7 @@ export class CommandPrompt {
       }
 
       try {
-        await this.runCommand(
-          agent,
-          sudoMcpServerManager.getMcpServerManager(),
-          sudoMcpServerManager,
-          cmds
-        );
+        await this.runCommand(agent, sudoMcpServerManager, cmds);
       } catch (e) {
         console.log(`ERROR: ${e}`);
       }
@@ -78,13 +73,12 @@ export class CommandPrompt {
 
   async runCommand(
     agent: IConversation,
-    mcpServerManager: IMcpServerManager,
     sudoMcpServerManager: ISkillManager,
     cmds: string[]
   ) {
     switch (cmds[0]) {
       case "lt":
-        this.listTools(mcpServerManager);
+        this.listTools(sudoMcpServerManager);
         break;
       case "ls":
         this.listServers(sudoMcpServerManager);
@@ -93,22 +87,22 @@ export class CommandPrompt {
         await this.addServer(sudoMcpServerManager, cmds[1]);
         break;
       case "rs":
-        await mcpServerManager.removeMcpServer(cmds[1]);
+        await sudoMcpServerManager.removeMcpServer(cmds[1]);
         break;
       case "e":
-        mcpServerManager.enableTool(cmds[1], cmds[2]);
+        sudoMcpServerManager.enableTool(cmds[1], cmds[2]);
         console.log(`Enabled tool ${cmds[2]} for server ${cmds[1]}`);
         break;
       case "d":
-        mcpServerManager.disableTool(cmds[1], cmds[2]);
+        sudoMcpServerManager.disableTool(cmds[1], cmds[2]);
         console.log(`Disabled tool ${cmds[2]} for server ${cmds[1]}`);
         break;
       case "ea":
-        mcpServerManager.enableAllTools(cmds[1]);
+        sudoMcpServerManager.enableAllTools(cmds[1]);
         console.log(`Enabled all tools for server ${cmds[1]}`);
         break;
       case "da":
-        mcpServerManager.disableAllTools(cmds[1]);
+        sudoMcpServerManager.disableAllTools(cmds[1]);
         console.log(`Disabled all tools for server ${cmds[1]}`);
         break;
       case "wc":
@@ -183,10 +177,9 @@ Have you installed server ${serverName} using the SudoMCP CLI tool?`;
         throw e;
       }
     }
-    const msm = sudoMcpServerManager.getMcpServerManager();
     console.log(`Added server: ${serverName} (enabled all tools).`);
     console.log(`Current tool list:`);
-    this.listTools(msm);
+    this.listTools(sudoMcpServerManager);
   }
 
   writeConversation(agent: IConversation, fileName: string) {

package/dist/agent/src/chat/frontendClient.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrontendChatClient = void 0;
-class FrontendChatClient {
-    constructor(ws, onMessageCB, onConnectionClosedCB) {
-        this.ws = ws;
-        this.onMessageCB = onMessageCB;
-        this.onConnectionClosedCB = onConnectionClosedCB;
-        this.closed = false;
-    }
-    static async initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB) {
-        return new Promise((resolve, reject) => {
-            const urlParams = new URLSearchParams(params);
-            const url = `ws://${host}:${port}?${urlParams}`;
-            const ws = new WebSocket(url, [token]);
-            console.log("created ws");
-            const client = new FrontendChatClient(ws, onMessageCB, onConnectionClosedCB);
-            ws.onopen = async () => {
-                console.log("opened");
-                ws.onmessage = (ev) => {
-                    try {
-                        const msgData = ev.data;
-                        if (typeof msgData !== "string") {
-                            throw `expected "string" data, got ${typeof msgData}`;
-                        }
-                        console.debug(`[client.onmessage]: ${msgData}`);
-                        const msg = JSON.parse(msgData);
-                        client.onMessageCB(msg);
-                    }
-                    catch (e) {
-                        client.close();
-                        throw e;
-                    }
-                };
-                resolve(client);
-            };
-            ws.onclose = (event) => {
-                console.log("closed");
-                console.log(`[client] WebSocket connection closed: ${JSON.stringify(event)}`);
-                client.closed = true;
-                onConnectionClosedCB();
-            };
-            ws.onerror = (error) => {
-                console.error("[client] WebSocket error:", error);
-                reject(error);
-                client.closed = true;
-                onConnectionClosedCB();
-            };
-        });
-    }
-    static async init(host, port, token, onMessageCB, onConnectionClosedCB, sessionId = "untitled", agentProfileId = undefined) {
-        const params = { session_id: sessionId };
-        if (agentProfileId) {
-            params["agent_profile_id"] = agentProfileId;
-        }
-        return FrontendChatClient.initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB);
-    }
-    sendMessage(message) {
-        if (this.closed) {
-            throw new Error("Cannot send message on closed connection");
-        }
-        const data = JSON.stringify(message);
-        this.ws.send(data);
-    }
-    close() {
-        this.closed = true;
-        this.onConnectionClosedCB();
-        this.ws.close();
-    }
-    isClosed() {
-        return this.closed;
-    }
-}
-exports.FrontendChatClient = FrontendChatClient;

package/src/chat/frontendClient.ts

@@ -1,123 +0,0 @@
-import { ServerToClient, ClientToServer } from "./messages";
-
-type OnMessageCallback = (msg: ServerToClient) => void;
-type OnConnectionClosedCallback = () => void;
-
-export class FrontendChatClient {
-  private ws: WebSocket;
-  private onMessageCB: OnMessageCallback;
-  private onConnectionClosedCB: OnConnectionClosedCallback;
-  private closed: boolean;
-
-  private constructor(
-    ws: WebSocket,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback
-  ) {
-    this.ws = ws;
-    this.onMessageCB = onMessageCB;
-    this.onConnectionClosedCB = onConnectionClosedCB;
-    this.closed = false;
-  }
-
-  static async initWithParams(
-    host: string,
-    port: number,
-    token: string,
-    params: Record<string, string>,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback
-  ): Promise<FrontendChatClient> {
-    return new Promise((resolve, reject) => {
-      const urlParams = new URLSearchParams(params);
-      const url = `ws://${host}:${port}?${urlParams}`;
-
-      const ws = new WebSocket(url, [token]);
-      console.log("created ws");
-
-      const client = new FrontendChatClient(
-        ws,
-        onMessageCB,
-        onConnectionClosedCB
-      );
-
-      ws.onopen = async () => {
-        console.log("opened");
-
-        ws.onmessage = (ev: MessageEvent) => {
-          try {
-            const msgData = ev.data;
-            if (typeof msgData !== "string") {
-              throw `expected "string" data, got ${typeof msgData}`;
-            }
-            console.debug(`[client.onmessage]: ${msgData}`);
-            const msg: ServerToClient = JSON.parse(msgData);
-            client.onMessageCB(msg);
-          } catch (e) {
-            client.close();
-            throw e;
-          }
-        };
-        resolve(client);
-      };
-
-      ws.onclose = (event) => {
-        console.log("closed");
-        console.log(
-          `[client] WebSocket connection closed: ${JSON.stringify(event)}`
-        );
-        client.closed = true;
-        onConnectionClosedCB();
-      };
-
-      ws.onerror = (error) => {
-        console.error("[client] WebSocket error:", error);
-        reject(error);
-
-        client.closed = true;
-        onConnectionClosedCB();
-      };
-    });
-  }
-
-  public static async init(
-    host: string,
-    port: number,
-    token: string,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback,
-    sessionId: string = "untitled",
-    agentProfileId: string | undefined = undefined
-  ): Promise<FrontendChatClient> {
-    const params: Record<string, string> = { session_id: sessionId };
-    if (agentProfileId) {
-      params["agent_profile_id"] = agentProfileId;
-    }
-    return FrontendChatClient.initWithParams(
-      host,
-      port,
-      token,
-      params,
-      onMessageCB,
-      onConnectionClosedCB
-    );
-  }
-
-  public sendMessage(message: ClientToServer): void {
-    if (this.closed) {
-      throw new Error("Cannot send message on closed connection");
-    }
-    const data = JSON.stringify(message);
-    this.ws.send(data);
-  }
-
-  public close(): void {
-    this.closed = true;
-    this.onConnectionClosedCB();
-    this.ws.close();
-  }
-
-  public isClosed(): boolean {
-    return this.closed;
-  }
-}