@xalia/agent 0.5.4 → 0.5.5

package/src/tool/chatMain.ts

@@ -9,16 +9,20 @@ import {
 } from "cmd-ts";
 import { stdout } from "process";
 import * as fs from "fs";
+import { strict as assert } from "assert";
 
 import { configuration } from "@xalia/xmcp/tool";
 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 { Prompt } from "./prompt";
+import { IPrompt, Prompt, ScriptPrompt } from "./prompt";
 import * as options from "./options";
+import { CommandPrompt } from "./commandPrompt";
+import { NODE_PLATFORM } from "./nodePlatform";
 
 const logger = getLogger();
 
@@ -114,19 +118,23 @@ const client = command({
       return;
     }
 
-    if (script) {
-      await runScript(host, port, apiKey, session, agentProfile, script);
-      return;
-    }
-
     const onMessage = getCLIOnMessage();
-    const repl = new Prompt();
+    const repl: IPrompt = (() => {
+      if (script) {
+        const scriptLines = fs.readFileSync(script, "utf8").split("\n");
+        return new ScriptPrompt(scriptLines);
+      }
+      return new Prompt();
+    })();
+    const cmdPrompt = new CommandPrompt(repl);
+
     const client = await ChatClient.init(
       host,
       port,
       apiKey,
       onMessage,
-      () => repl.shutdown(),
+      async () => await cmdPrompt.shutdown(),
+      NODE_PLATFORM,
       session,
       agentProfile
     );
@@ -134,13 +142,20 @@ const client = command({
     logger.debug("client created");
 
     while (true) {
-      const msgText = await repl.run("ME: ");
-      logger.debug(`prompt got '${msgText}'`);
+      const [msgText, imageFile] = await cmdPrompt.getNextPrompt(
+        undefined as unknown as IConversation, // TODO: client
+        client.getSudoMcpServerManager()
+      );
+      assert(imageFile === undefined);
+
       if (msgText === undefined) {
         logger.debug("exiting...");
         client.close();
         return;
       }
+
+      // TODO: other prompts
+
       if (msgText.length > 0) {
         const msg: ClientUserMessage = {
           type: "msg",
@@ -176,43 +191,12 @@ function getCLIOnMessage(): (msg: ServerToClient) => void {
         }
         break;
       default:
-        stdout.write(`(${JSON.stringify(msg)})\n`);
+        stdout.write(`(unrecognised) ${JSON.stringify(msg)}\n`);
         break;
     }
   };
 }
 
-async function runScript(
-  host: string,
-  port: number,
-  apiKey: string,
-  session: string,
-  agentProfile: string | undefined,
-  script: string
-): Promise<void> {
-  const client = await ChatClient.init(
-    host,
-    port,
-    apiKey,
-    getCLIOnMessage(),
-    () => {},
-    session,
-    agentProfile
-  );
-  const scriptData = fs.readFileSync(script, "utf8");
-  const lines = scriptData.split("\n");
-  for (const line of lines) {
-    await new Promise((r) => setTimeout(r, 1000));
-    client.sendMessage({ type: "msg", message: line });
-  }
-
-  // 2 second wait period
-  await new Promise((r) => setTimeout(r, 2000));
-
-  client.close();
-  return;
-}
-
 async function runClientTest(
   host: string,
   port: number,
@@ -224,7 +208,8 @@ async function runClientTest(
     port,
     apiKey,
     getCLIOnMessage(),
-    () => {},
+    async () => {},
+    NODE_PLATFORM,
     session
   );
 

package/src/tool/commandPrompt.ts

@@ -0,0 +1,252 @@
+import * as fs from "fs";
+import chalk from "chalk";
+import OpenAI from "openai";
+
+import { InvalidConfiguration } from "@xalia/xmcp/sdk";
+
+import { IConversation } from "../agent/agent";
+import { displayToolCall } from "../agent/tools";
+import { ISkillManager } from "../agent/sudoMcpServerManager";
+import { IMcpServerManager } from "../agent/mcpServerManager";
+
+import { IPrompt } from "./prompt";
+
+/**
+ * A prompt parser which can accept commands or messages from an IPrompt.
+ * Commands are sent to an IMcpServerManager, ISkillManager and IConversation.
+ */
+export class CommandPrompt {
+  prompt: IPrompt;
+
+  constructor(prompt: IPrompt) {
+    this.prompt = prompt;
+  }
+
+  shutdown(): Promise<void> {
+    return this.prompt.shutdown();
+  }
+
+  async getNextPrompt(
+    agent: IConversation,
+    sudoMcpServerManager: ISkillManager
+  ): Promise<[string | undefined, string | undefined]> {
+    while (true) {
+      // Get a line, detecting the EOF signal.
+      const line = await this.prompt.run();
+      if (typeof line === "undefined") {
+        console.log("closing ...");
+        return [undefined, undefined];
+      }
+      if (line.length === 0) {
+        continue;
+      }
+
+      // Extract prompt or commands
+      const { msg, cmds } = parsePrompt(line);
+
+      // If there are no commands, this must be a prompt only
+      if (!cmds) {
+        return [msg, undefined];
+      }
+
+      // There are commands.  If it's image, return [prompt, image].  If it's
+      // quit, return [undefined, undefined], otherwise it must be a command.
+      // Execute it and prompt again.
+      switch (cmds[0]) {
+        case "i": // image
+          return [msg, cmds[1]];
+        case "q":
+        case "quit":
+        case "exit":
+          return [undefined, undefined];
+        default:
+          break;
+      }
+
+      try {
+        await this.runCommand(
+          agent,
+          sudoMcpServerManager.getMcpServerManager(),
+          sudoMcpServerManager,
+          cmds
+        );
+      } catch (e) {
+        console.log(`ERROR: ${e}`);
+      }
+    }
+  }
+
+  async runCommand(
+    agent: IConversation,
+    mcpServerManager: IMcpServerManager,
+    sudoMcpServerManager: ISkillManager,
+    cmds: string[]
+  ) {
+    switch (cmds[0]) {
+      case "lt":
+        this.listTools(mcpServerManager);
+        break;
+      case "ls":
+        this.listServers(sudoMcpServerManager);
+        break;
+      case "as":
+        await this.addServer(sudoMcpServerManager, cmds[1]);
+        break;
+      case "rs":
+        await mcpServerManager.removeMcpServer(cmds[1]);
+        break;
+      case "e":
+        mcpServerManager.enableTool(cmds[1], cmds[2]);
+        console.log(`Enabled tool ${cmds[2]} for server ${cmds[1]}`);
+        break;
+      case "d":
+        mcpServerManager.disableTool(cmds[1], cmds[2]);
+        console.log(`Disabled tool ${cmds[2]} for server ${cmds[1]}`);
+        break;
+      case "ea":
+        mcpServerManager.enableAllTools(cmds[1]);
+        console.log(`Enabled all tools for server ${cmds[1]}`);
+        break;
+      case "da":
+        mcpServerManager.disableAllTools(cmds[1]);
+        console.log(`Disabled all tools for server ${cmds[1]}`);
+        break;
+      case "wc":
+        this.writeConversation(agent, cmds[1]);
+        break;
+      case "wa":
+        this.writeAgentProfile(agent, cmds[1]);
+        break;
+      case "h":
+      case "help":
+      case "?":
+        this.helpMenu();
+        break;
+      default:
+        console.log(`error: Unknown command ${cmds[0]}`);
+    }
+  }
+
+  helpMenu() {
+    const write = console.log;
+    write(`Tool management commands:`);
+    write(`  ${chalk.yellow("/lt")}                 List tools: `);
+    write(`  ${chalk.yellow("/ls")}                 List servers`);
+    write(`  ${chalk.yellow("/as <server>")}        Add server`);
+    write(`  ${chalk.yellow("/rs <server>")}        Remove server`);
+    write(`  ${chalk.yellow("/e <server> <tool>")}  Enable tool`);
+    write(`  ${chalk.yellow("/d <server> <tool>")}  Disable tool`);
+    write(`  ${chalk.yellow("/ea <server>")}        Enable all tools`);
+    write(`  ${chalk.yellow("/da <server>")}        Disable all tools`);
+    write(`  ${chalk.yellow("/wc <file-name>")}     Write conversation file`);
+    write(`  ${chalk.yellow("/wa <file-name>")}     Write agent profile file`);
+    write(`  ${chalk.yellow("/q")}                  Quit`);
+  }
+
+  listTools(mcpServerManager: IMcpServerManager) {
+    console.log("Mcp servers and tools (* - enabled):");
+
+    const serverNames = mcpServerManager.getMcpServerNames();
+    for (const serverName of serverNames) {
+      const server = mcpServerManager.getMcpServer(serverName);
+      console.log(` ${chalk.green(serverName)}`);
+      const tools = server.getTools();
+      const enabled = server.getEnabledTools();
+      for (const tool of tools) {
+        const isEnabled = enabled[tool.name] ? "*" : " ";
+        console.log(`  [${isEnabled}] ${tool.name}`);
+      }
+    }
+  }
+
+  listServers(sudoMcpServerManager: ISkillManager) {
+    console.log(`Available MCP Servers:`);
+
+    const serverBriefs = sudoMcpServerManager.getServerBriefs();
+    serverBriefs.sort((a, b) => a.name.localeCompare(b.name));
+    for (const brief of serverBriefs) {
+      console.log(`- ${chalk.green(brief.name)}: ${brief.description}`);
+    }
+  }
+
+  /**
+   * Adds server and enables all tools.
+   */
+  async addServer(sudoMcpServerManager: ISkillManager, serverName: string) {
+    try {
+      await sudoMcpServerManager.addMcpServer(serverName, true);
+    } catch (e) {
+      if (e instanceof InvalidConfiguration) {
+        throw `${e}. \n
+Have you installed server ${serverName} using the SudoMCP CLI tool?`;
+      } else {
+        throw e;
+      }
+    }
+    const msm = sudoMcpServerManager.getMcpServerManager();
+    console.log(`Added server: ${serverName} (enabled all tools).`);
+    console.log(`Current tool list:`);
+    this.listTools(msm);
+  }
+
+  writeConversation(agent: IConversation, fileName: string) {
+    const conversation = agent.getConversation();
+    fs.writeFileSync(fileName, JSON.stringify(conversation), {
+      encoding: "utf8",
+    });
+    console.log(`Conversation written to ${fileName}`);
+  }
+
+  writeAgentProfile(agent: IConversation, fileName: string) {
+    const profile = agent.getAgentProfile();
+    fs.writeFileSync(fileName, JSON.stringify(profile));
+    console.log(`AgentProfile written to ${fileName}`);
+  }
+
+  async promptToolCall(
+    toolCall: OpenAI.ChatCompletionMessageToolCall
+  ): Promise<boolean> {
+    displayToolCall(toolCall);
+    const response = await this.prompt.run("Approve tool call? (Y/n) ");
+    return response === "y" || response === "yes" || response == "";
+  }
+}
+
+/**
+ * Support prompts of the form:
+ *  - some text                (msg: some text, cmds: undefined)
+ *  - :i image.png some text   (msg: some text, cmds: ["i", "image.png"])
+ *  - :i image.png             (msg: undefined, cmds: ["i", "image.png"])
+ *  - :l                       (msg: undefined, cmds: ["l"])
+ *  - :e toolName ..           (msg: undefined, cmds: ["e", "toolName", ...])
+ *  - :ea toolName ..          (msg: undefined, cmds: ["ea", "toolName", ...])
+ */
+export function parsePrompt(prompt: string): {
+  msg?: string;
+  cmds?: string[];
+} {
+  prompt = prompt.trim();
+
+  let msg: string | undefined = undefined;
+  let cmds: string[] | undefined = undefined;
+
+  if (prompt.startsWith(":") || prompt.startsWith("/")) {
+    cmds = prompt.split(" ");
+    cmds[0] = cmds[0].slice(1);
+
+    if (cmds[0] == "i") {
+      // :i is special as it may have a trailing message
+      const fileDelim = prompt.indexOf(" ", 3);
+      if (fileDelim < 0) {
+        cmds = [cmds[0], prompt.slice(3)];
+      } else {
+        msg = prompt.slice(fileDelim + 1);
+        cmds = [cmds[0], prompt.slice(3, fileDelim)];
+      }
+    }
+  } else {
+    msg = prompt;
+  }
+
+  return { msg, cmds };
+}

package/src/tool/prompt.ts

@@ -1,8 +1,16 @@
+import { getLogger } from "@xalia/xmcp/sdk";
 import readline from "readline";
 
+const logger = getLogger();
+
 const DEFAULT_PROMPT: string = "USER: ";
 
-export class Prompt {
+export interface IPrompt {
+  run(prompt?: string): Promise<string | undefined>;
+  shutdown(): Promise<void>;
+}
+
+export class Prompt implements IPrompt {
   private line: string | undefined;
   private online: { (line: string | undefined): void } | undefined;
   // private onerror: { (reason?: any): void } | undefined;
@@ -41,7 +49,7 @@ export class Prompt {
     });
   }
 
-  shutdown(): void {
+  async shutdown(): Promise<void> {
     this.prompt.close();
   }
 
@@ -54,40 +62,33 @@ export class Prompt {
 }
 
 /**
- * Support prompts:
- *  - some text                (msg: some text, cmds: undefined)
- *  - :i image.png some text   (msg: some text, cmds: ["i", "image.png"])
- *  - :i image.png             (msg: undefined, cmds: ["i", "image.png"])
- *  - :l                       (msg: undefined, cmds: ["l"])
- *  - :e toolName ..           (msg: undefined, cmds: ["e", "toolName", ...])
- *  - :ea toolName ..          (msg: undefined, cmds: ["ea", "toolName", ...])
+ * A prompt which just reads from a script
  */
-export function parsePrompt(prompt: string): {
-  msg?: string;
-  cmds?: string[];
-} {
-  prompt = prompt.trim();
+export class ScriptPrompt implements IPrompt {
+  lines: string[];
 
-  let msg: string | undefined = undefined;
-  let cmds: string[] | undefined = undefined;
+  constructor(lines: string[]) {
+    this.lines = lines;
+  }
 
-  if (prompt.startsWith(":") || prompt.startsWith("/")) {
-    cmds = prompt.split(" ");
-    cmds[0] = cmds[0].slice(1);
+  run(_prompt?: string): Promise<string | undefined> {
+    return new Promise((r) => {
+      setTimeout(() => {
+        logger.debug(`[ScriptPrompt.run]: ${this.lines.length} remaining`);
 
-    if (cmds[0] == "i") {
-      // :i is special as it may have a trailing message
-      const fileDelim = prompt.indexOf(" ", 3);
-      if (fileDelim < 0) {
-        cmds = [cmds[0], prompt.slice(3)];
-      } else {
-        msg = prompt.slice(fileDelim + 1);
-        cmds = [cmds[0], prompt.slice(3, fileDelim)];
-      }
-    }
-  } else {
-    msg = prompt;
+        if (this.lines.length === 0) {
+          logger.debug("[ScriptPrompt.run]: returning undefined");
+          r(undefined);
+        } else {
+          const line = this.lines.shift();
+          logger.debug(`[ScriptPrompt.run]: returning: ${line}`);
+          r(line);
+        }
+      }, 1000);
+    });
   }
 
-  return { msg, cmds };
+  shutdown(): Promise<void> {
+    return new Promise((r) => setTimeout(r, 100));
+  }
 }