@xalia/agent 0.5.4 → 0.5.5

package/src/chat/messages.ts

@@ -4,6 +4,8 @@ import {
   ChatCompletionToolMessageParam,
   ChatCompletionMessageToolCall,
 } from "openai/resources.mjs";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { McpServerBrief } from "@xalia/xmcp/sdk";
 
 /**
  * Message from a user to the server
@@ -13,6 +15,84 @@ export type ClientUserMessage = {
   message: string;
 };
 
+/**
+ * Message to add an MCP server to the agent
+ */
+export type ClientAddMcpServer = {
+  type: "add_mcp_server";
+  server_name: string;
+  enable_all: boolean;
+};
+
+/**
+ * Message to remove an MCP server from the agent
+ */
+export type ClientRemoveMcpServer = {
+  type: "remove_mcp_server";
+  server_name: string;
+};
+
+/**
+ * Enable a specific tool
+ */
+export type ClientEnableMcpServerTool = {
+  type: "enable_mcp_server_tool";
+  server_name: string;
+  tool: string;
+};
+
+/**
+ * Disable a specific tool
+ */
+export type ClientDisableMcpServerTool = {
+  type: "disable_mcp_server_tool";
+  server_name: string;
+  tool: string;
+};
+
+export type ClientEnableAllMcpServerTools = {
+  type: "enable_all_mcp_server_tools";
+  server_name: string;
+};
+
+export type ClientDisableAllMcpServerTools = {
+  type: "disable_all_mcp_server_tools";
+  server_name: string;
+};
+
+export type ClientSetSystemPrompt = {
+  type: "set_system_prompt";
+  system_prompt: string;
+};
+
+export type ClientSetModel = {
+  type: "set_model";
+  model: string;
+};
+
+export type ClientToServer =
+  | ClientUserMessage
+  | ClientAddMcpServer
+  | ClientRemoveMcpServer
+  | ClientEnableMcpServerTool
+  | ClientDisableMcpServerTool
+  | ClientEnableAllMcpServerTools
+  | ClientDisableAllMcpServerTools
+  | ClientSetSystemPrompt
+  | ClientSetModel;
+
+///
+/// Server -> Client Messages
+///
+
+/**
+ * Error in response to an invalid request from the client
+ */
+export type ServerError = {
+  type: "error";
+  message: string;
+};
+
 /**
  * (from server) Chat history
  */
@@ -57,6 +137,11 @@ export type ServerAgentMessageChunk = {
   end: boolean;
 };
 
+export type ServerMcpServerBriefs = {
+  type: "mcp_server_briefs";
+  server_briefs: McpServerBrief[];
+};
+
 /**
  * For information only (to keep the chat window consistent).
  */
@@ -80,12 +165,71 @@ export type ServerTyping = {
   from: string;
 };
 
-export type ClientToServer = ClientUserMessage;
+export type ServerMcpServerAdded = {
+  type: "mcp_server_added";
+  server_name: string;
+  tools: Tool[];
+  enabled_tools: string[];
+};
+
+export type ServerMcpServerRemoved = {
+  type: "mcp_server_removed";
+  server_name: string;
+};
+
+export type ServerMcpServerToolEnabled = {
+  type: "mcp_server_tool_enabled";
+  server_name: string;
+  tool: string;
+};
+
+export type ServerMcpServerToolDisabled = {
+  type: "mcp_server_tool_disabled";
+  server_name: string;
+  tool: string;
+};
+
+export type ServerSystemPromptUpdated = {
+  type: "system_prompt_updated";
+  system_prompt: string;
+};
+
+export type ServerModelUpdated = {
+  type: "model_updated";
+  model: string;
+};
+
+export type ServerToClientStateUpdate =
+  | ServerMcpServerAdded
+  | ServerMcpServerRemoved
+  | ServerMcpServerToolEnabled
+  | ServerMcpServerToolDisabled
+  | ServerSystemPromptUpdated
+  | ServerModelUpdated;
+
+export type ServerOpenUrl = {
+  type: "open_url";
+  url: string;
+  display_name: string;
+};
+
+export type ServerApproveToolCall = {
+  type: "approve_tool_call";
+  tbd: string;
+};
+
+export type ServerToClientActions = ServerOpenUrl | ServerApproveToolCall;
 
 export type ServerToClient =
+  | ServerError
   | ServerUserJoined
   | ServerUserLeft
   | ServerUserMessage
   | ServerAgentMessage
   | ServerAgentMessageChunk
-  | ServerTyping;
+  | ServerMcpServerBriefs
+  | ServerToolCall
+  | ServerToolCallResult
+  | ServerTyping
+  | ServerToClientStateUpdate
+  | ServerToClientActions;

package/src/chat/server.ts

@@ -31,7 +31,7 @@ async function resolveAgentProfileId(
   }
 
   ap = await db.getSavedAgentProfileByName(
-    userData.user_uuid,
+    userData.uuid,
     agentProfileIdentifier
   );
   logger.debug(`[resolveAgentProfileId]: by name: {JSON.stringify(ap)}`);
@@ -54,7 +54,7 @@ async function resolveSessionIdFromIdentifier(
     // Interpret as an id, or as a number under the current user.
     session = await db.getSessionById(compound);
     if (!session) {
-      session = await db.getSessionByName(userData.user_uuid, compound);
+      session = await db.getSessionByName(userData.uuid, compound);
     }
   } else {
     session = await db.getSessionByName(compound[0], compound[1]);
@@ -114,7 +114,7 @@ async function findOrCreateSession(
     throw `no agent profile: ${agentProfileIdParam}`;
   }
 
-  return db.createSession(userData.user_uuid, query.session_id, agentProfileId);
+  return db.createSession(userData.uuid, query.session_id, agentProfileId);
 }
 
 export async function runServer(

package/src/test/db.test.ts

@@ -15,6 +15,12 @@ const AGENT_PROFILE: AgentProfile = {
   mcp_settings: {},
 };
 
+const AGENT_PROFILE_2: AgentProfile = {
+  model: undefined,
+  system_prompt: "You are a very helpful agent.",
+  mcp_settings: { simplecalc: [] },
+};
+
 async function createDummyUser(db: Database): Promise<void> {
   const apiClient = new ApiClient(LOCAL_SERVER_URL, "dummy_key");
   const user = await apiClient.getUserBrief("dummy_user");
@@ -28,12 +34,12 @@ async function createDummyUser(db: Database): Promise<void> {
 }
 
 describe("DB", () => {
-  it("should get existing user", async function () {
+  it("should get data for existing user", async function () {
     const db = getLocalDB();
     await createDummyUser(db);
     const dummyUser = await db.getUserDataFromApiKey("dummy_key");
     expect(dummyUser).eql({
-      user_uuid: "dummy_user",
+      uuid: "dummy_user",
       nickname: "Dummy User",
     });
   });
@@ -44,6 +50,15 @@ describe("DB", () => {
     expect(dummyUser).to.equal(undefined);
   });
 
+  it("should get user by uuid", async function () {
+    const db = getLocalDB();
+    await createDummyUser(db);
+    const dummyUser = await db.getUserFromUuid("dummy_user");
+    assert(dummyUser);
+    expect(dummyUser.uuid).eql("dummy_user");
+    expect(dummyUser.nickname).eql("Dummy User");
+  });
+
   it("should create and retrieve agent profiles", async function () {
     const db = getLocalDB();
 
@@ -74,6 +89,24 @@ describe("DB", () => {
     expect(agentProfile).eql(AGENT_PROFILE);
   });
 
+  it("should update agent profiles", async function () {
+    const db = getLocalDB();
+
+    await db.clearAgentProfiles();
+    const agentProfileId = await db.createAgentProfile(
+      "dummy_user",
+      "test_profile",
+      AGENT_PROFILE
+    );
+    expect(agentProfileId).to.not.equal(undefined);
+    assert(agentProfileId);
+
+    await db.updateAgentProfile(agentProfileId, AGENT_PROFILE_2);
+
+    const agentProfileFromDB = (await db.getAgentProfileById(agentProfileId))!;
+    expect(agentProfileFromDB).eql(AGENT_PROFILE_2);
+  });
+
   it("should create and retrieve sessions", async function () {
     const db = getLocalDB();
 

package/src/test/openaiStreaming.test.ts

@@ -0,0 +1,142 @@
+import { expect } from "chai";
+
+import { OpenAI } from "openai";
+import {
+  initializeCompletion,
+  updateCompletion,
+} from "../agent/openAILLMStreaming";
+
+const TEST_STANDARD: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
+  {
+    id: "chatcmpl-BzBqzVs5w0kU5we3KIUN1Q4FAZXjg",
+    choices: [
+      {
+        delta: { content: "!" },
+        finish_reason: null,
+        index: 0,
+        logprobs: null,
+      },
+    ],
+    created: 1753923273,
+    model: "gpt-4o-2024-08-06",
+    object: "chat.completion.chunk",
+    service_tier: "default",
+    system_fingerprint: "fp_07871e2ad8",
+  },
+  {
+    id: "chatcmpl-BzBqzVs5w0kU5we3KIUN1Q4FAZXjg",
+    choices: [{ delta: {}, finish_reason: "stop", index: 0, logprobs: null }],
+    created: 1753923273,
+    model: "gpt-4o-2024-08-06",
+    object: "chat.completion.chunk",
+    service_tier: "default",
+    system_fingerprint: "fp_07871e2ad8",
+  },
+];
+
+const TEST_TRAILING_USAGE: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
+  {
+    id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
+    choices: [
+      {
+        delta: { content: "test", role: "assistant" },
+        finish_reason: "stop",
+        index: 0,
+        logprobs: null,
+      },
+    ],
+    created: 1753923406,
+    model: "openai/gpt-4o",
+    object: "chat.completion.chunk",
+    system_fingerprint: "fp_a288987b44",
+  },
+  {
+    id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
+    choices: [
+      {
+        delta: { content: "", role: "assistant" },
+        finish_reason: null,
+        index: 0,
+        logprobs: null,
+      },
+    ],
+    created: 1753923406,
+    model: "openai/gpt-4o",
+    object: "chat.completion.chunk",
+    usage: {
+      completion_tokens: 50,
+      prompt_tokens: 271,
+      total_tokens: 321,
+      completion_tokens_details: { reasoning_tokens: 0 },
+      prompt_tokens_details: { cached_tokens: 0 },
+    },
+  },
+];
+
+describe("OpenAI Streaming", () => {
+  it("should support standard termination", async function () {
+    const chunks = TEST_STANDARD;
+    expect(chunks.length).eql(2);
+    const { initMessage } = initializeCompletion(chunks[0]);
+    updateCompletion(initMessage, chunks[1]);
+
+    expect(initMessage).eql({
+      id: "chatcmpl-BzBqzVs5w0kU5we3KIUN1Q4FAZXjg",
+      choices: [
+        {
+          message: {
+            content: "!",
+            role: "assistant",
+            refusal: null,
+            tool_calls: undefined,
+          },
+          finish_reason: "stop",
+          index: 0,
+          logprobs: null,
+        },
+      ],
+      created: 1753923273,
+      model: "gpt-4o-2024-08-06",
+      object: "chat.completion",
+      service_tier: "default",
+      system_fingerprint: "fp_07871e2ad8",
+      usage: undefined,
+    });
+  });
+
+  it("should support trailing usage", async function () {
+    const chunks = TEST_TRAILING_USAGE;
+    expect(chunks.length).eql(2);
+    const { initMessage } = initializeCompletion(chunks[0]);
+    updateCompletion(initMessage, chunks[1]);
+
+    expect(initMessage).eql({
+      id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
+      choices: [
+        {
+          message: {
+            content: "test",
+            role: "assistant",
+            refusal: null,
+            tool_calls: undefined,
+          },
+          finish_reason: "stop",
+          index: 0,
+          logprobs: null,
+        },
+      ],
+      created: 1753923406,
+      model: "openai/gpt-4o",
+      object: "chat.completion",
+      service_tier: undefined,
+      system_fingerprint: "fp_a288987b44",
+      usage: {
+        completion_tokens: 50,
+        prompt_tokens: 271,
+        total_tokens: 321,
+        completion_tokens_details: { reasoning_tokens: 0 },
+        prompt_tokens_details: { cached_tokens: 0 },
+      },
+    });
+  });
+});

package/src/test/prompt.test.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { parsePrompt } from "../tool/prompt";
+import { parsePrompt } from "../tool/commandPrompt";
 
 describe("Prompt", () => {
   it("should recognise commands", async function () {

package/src/test/sudoMcpServerManager.test.ts

@@ -47,7 +47,7 @@ describe("SudoMcpServerManager", async () => {
 
   it("should add a new MCP server", async () => {
     const [, sm] = await getServerManagers();
-    await sm.addMcpServer("sudomcp_simplecalc");
+    await sm.addMcpServer("sudomcp_simplecalc", true);
     const serverBriefs = sm.getServerBriefs();
     expect(
       serverBriefs.some((brief) => brief.name === "sudomcp_simplecalc")

package/src/tool/agentChat.ts

@@ -1,21 +1,18 @@
 import yocto from "yocto-spinner";
 import { Spinner } from "yocto-spinner";
-import * as fs from "fs";
 import OpenAI from "openai";
 import chalk from "chalk";
 
 import { configuration, utils } from "@xalia/xmcp/tool";
-import { getLogger, InvalidConfiguration } from "@xalia/xmcp/sdk";
+import { getLogger } from "@xalia/xmcp/sdk";
 
-import { Agent, AgentProfile } from "../agent/agent";
-import { McpServerManager } from "../agent/mcpServerManager";
-import { displayToolCall } from "../agent/tools";
-import { SkillManager } from "../agent/sudoMcpServerManager";
+import { AgentProfile } from "../agent/agent";
 import { createAgentWithSkills } from "../agent/agentUtils";
 
 import { loadImageB64OrUndefined } from "./files";
-import { Prompt, parsePrompt } from "./prompt";
 import { NODE_PLATFORM } from "./nodePlatform";
+import { CommandPrompt } from "./commandPrompt";
+import { IPrompt, Prompt } from "./prompt";
 
 const logger = getLogger();
 
@@ -66,6 +63,9 @@ export async function runChat(
     }
   };
 
+  const repl: IPrompt = new Prompt();
+  const cmdPrompt = new CommandPrompt(repl);
+
   let remainingApprovedToolCalls = approveToolsUpTo;
   const onToolCall = async (toolCall: OpenAI.ChatCompletionMessageToolCall) => {
     if (remainingApprovedToolCalls !== 0) {
@@ -74,7 +74,7 @@ export async function runChat(
     }
 
     spinner.stop().clear();
-    const result = await promptToolCall(repl, toolCall);
+    const result = await cmdPrompt.promptToolCall(toolCall);
     spinner.start();
     return result;
   };
@@ -108,12 +108,13 @@ export async function runChat(
     console.log(`USER: ${prompt}`);
   }
 
-  const repl = new Prompt();
-
   // Conversation loop
   while (true) {
     if (!prompt) {
-      const [msg, img] = await getNextPrompt(repl, agent, sudoMcpServerManager);
+      const [msg, img] = await cmdPrompt.getNextPrompt(
+        agent,
+        sudoMcpServerManager
+      );
       if (!msg && !img) {
         break;
       }
@@ -137,7 +138,7 @@ export async function runChat(
 
   // Shutdown the agent
 
-  repl.shutdown();
+  cmdPrompt.shutdown();
   await agent.shutdown();
 
   logger.debug("shutdown done");
@@ -147,202 +148,3 @@ export async function runChat(
  * Read lines from the prompt, parsing any commands, and return once there is
  * a prompt and/or image for the llm.  Both undefined means exit.
  */
-async function getNextPrompt(
-  repl: Prompt,
-  agent: Agent,
-  sudoMcpServerManager: SkillManager
-): Promise<[string | undefined, string | undefined]> {
-  while (true) {
-    // Get a line, detecting the EOF signal.
-    const line = await repl.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 runCommand(
-        agent,
-        agent.getMcpServerManager(),
-        sudoMcpServerManager,
-        cmds
-      );
-    } catch (e) {
-      console.log(`ERROR: ${e}`);
-    }
-  }
-}
-
-async function runCommand(
-  agent: Agent,
-  mcpServerManager: McpServerManager,
-  sudoMcpServerManager: SkillManager,
-  cmds: string[]
-) {
-  switch (cmds[0]) {
-    case "lt":
-      listTools(mcpServerManager);
-      break;
-    case "ls":
-      listServers(sudoMcpServerManager);
-      break;
-    case "as":
-      await 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":
-      writeConversation(agent, cmds[1]);
-      break;
-    case "wa":
-      writeAgentProfile(agent, cmds[1]);
-      break;
-    case "h":
-    case "help":
-    case "?":
-      helpMenu();
-      break;
-    default:
-      console.log(`error: Unknown command ${cmds[0]}`);
-  }
-}
-
-function helpMenu() {
-  console.log(`Tool management commands:`);
-  console.log(`  ${chalk.yellow("/lt")}                          List tools: `);
-  console.log(`  ${chalk.yellow("/ls")}                          List servers`);
-  console.log(`  ${chalk.yellow("/as <server-name>")}            Add server`);
-  console.log(
-    `  ${chalk.yellow("/rs <server-name>")}            Remove server`
-  );
-  console.log(`  ${chalk.yellow("/e <server-name> <tool-name>")} Enable tool`);
-  console.log(`  ${chalk.yellow("/d <server-name> <tool-name>")} Disable tool`);
-  console.log(
-    `  ${chalk.yellow("/ea <server-name>")}            Enable all tools`
-  );
-  console.log(
-    `  ${chalk.yellow("/da <server-name>")}            Disable all tools`
-  );
-  console.log(
-    `  ${chalk.yellow("/wc <file-name>")}              Write conversation file`
-  );
-  console.log(
-    `  ${chalk.yellow("/wa <file-name>")}              Write agent profile file`
-  );
-
-  console.log(`  ${chalk.yellow("/q")}                           Quit`);
-}
-
-function listTools(mcpServerManager: McpServerManager) {
-  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}`);
-    }
-  }
-}
-
-function listServers(sudoMcpServerManager: SkillManager) {
-  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 function addServer(
-  sudoMcpServerManager: SkillManager,
-  serverName: string
-) {
-  try {
-    await sudoMcpServerManager.addMcpServer(serverName);
-  } catch (e) {
-    if (e instanceof InvalidConfiguration) {
-      throw `${e}. \n
-      Have you installed server ${serverName} using the SudoMCP CLI tool?`;
-    } else {
-      throw e;
-    }
-  }
-  sudoMcpServerManager.getMcpServerManager().enableAllTools(serverName);
-  console.log(`Added server: ${serverName} and enabled all tools.`);
-  console.log(`Current tool list:`);
-  listTools(sudoMcpServerManager.getMcpServerManager());
-}
-
-function writeConversation(agent: Agent, fileName: string) {
-  const conversation = agent.getConversation();
-  fs.writeFileSync(fileName, JSON.stringify(conversation), {
-    encoding: "utf8",
-  });
-  console.log(`Conversation written to ${fileName}`);
-}
-
-function writeAgentProfile(agent: Agent, fileName: string) {
-  const profile = agent.getAgentProfile();
-  fs.writeFileSync(fileName, JSON.stringify(profile));
-  console.log(`AgentProfile written to ${fileName}`);
-}
-
-async function promptToolCall(
-  repl: Prompt,
-  toolCall: OpenAI.ChatCompletionMessageToolCall
-): Promise<boolean> {
-  displayToolCall(toolCall);
-  const response = await repl.run("Approve tool call? (Y/n) ");
-  return response === "y" || response === "yes" || response == "";
-}