@xalia/agent 1.0.19

package/src/sudoMcpServerManager.ts

@@ -0,0 +1,268 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { McpServerManager, McpServerManagerSettings } from "./mcpServerManager";
+import {
+  ApiClient,
+  McpServerBrief,
+  DEFAULT_SERVER_URL,
+  McpServerConfiguration,
+  getLogger,
+  verifyConfigForServer,
+  AuthenticationRequired,
+  McpServer,
+} from "@xalia/xmcp/sdk";
+import { strict as assert } from "assert";
+import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
+
+const logger = getLogger();
+
+export const LOCAL_SERVER_URL: string = "http://localhost:5001";
+
+/**
+ * ServerBrief with sanitized name, and original name in another field.
+ */
+class SanitizedServerBrief extends McpServerBrief {
+  readonly originalName: string;
+
+  private constructor() {
+    super("dummy", "dummy", "dummy", false, {}, "dummy", "dummy");
+    this.originalName = "dummy";
+  }
+
+  public static fromServerBrief(brief: McpServerBrief): SanitizedServerBrief {
+    const b = brief as unknown;
+    const origName = brief.name;
+    (b as any).originalName = origName; // eslint-disable-line
+    brief.name = sanitizeName(origName);
+    return b as SanitizedServerBrief;
+  }
+}
+
+/**
+ * Manages access to the catalogue of servers hosted by sudomcp.  Supports
+ * adding these servers to McpServerManager.
+ */
+export class SudoMcpServerManager {
+  private constructor(
+    private mcpServerManager: McpServerManager,
+    private apiClient: ApiClient,
+    private serverBriefs: SanitizedServerBrief[],
+    private serverBriefsMap: { [serverName: string]: SanitizedServerBrief },
+    private toolCache: { [serverName: string]: Tool[] },
+    private openUrl: (url: string) => void,
+    // Redirect to this page after successful authorization
+    private authorized_url: string | undefined
+  ) {}
+
+  /**
+   * Initialize an ApiClient to interface with SudoMCP backend and
+   * fetch the current list of ServerBriefs.
+   */
+  public static async initialize(
+    mcpServerManager: McpServerManager,
+    openUrl: (url: string) => void,
+    sudoMcpUrl?: string,
+    sudoMcpApiKey?: string,
+    authorized_url?: string
+  ): Promise<SudoMcpServerManager> {
+    // TODO: Keep it on here and pass to `McpServerManager.addMcpServer`
+    const apiClient = new ApiClient(
+      sudoMcpUrl ?? DEFAULT_SERVER_URL,
+      sudoMcpApiKey ?? "dummy_key"
+    );
+    // Fetch server list
+    const servers = await apiClient.search([]);
+
+    const [mcpServers, mcpServersMap] = buildServersList(servers);
+    return new SudoMcpServerManager(
+      mcpServerManager,
+      apiClient,
+      mcpServers,
+      mcpServersMap,
+      {},
+      openUrl,
+      authorized_url
+    );
+  }
+
+  /// TODO: Bit awkward that we have to restore via this class, but it's the
+  /// only class which knows how to restore (restart) the mcp servers.
+  public async restoreMcpSettings(
+    mcpSettings: McpServerManagerSettings,
+    serverConfigs: { [serverName: string]: McpServerConfiguration }
+  ): Promise<void> {
+    await this.restoreConfiguration(mcpSettings, serverConfigs);
+  }
+
+  /**
+   * Load the configuration from sudomcp, and enable the specified tools.
+   */
+  public async restoreConfiguration(
+    mcpConfig: McpServerManagerSettings,
+    serverConfigs: { [serverName: string]: McpServerConfiguration }
+  ): Promise<void> {
+    logger.debug("Restoring Mcp config");
+
+    // TODO: remove existing servers?
+
+    for (const [serverName, enabled] of Object.entries(mcpConfig)) {
+      logger.debug(` restoring "${serverName}" ...`);
+
+      if (Object.keys(enabled).length === 0) {
+        logger.debug(` restoring "${serverName}": (empty)`);
+        continue;
+      }
+
+      const serverConfig = serverConfigs[serverName] ?? {};
+      logger.debug(
+        ` restoring ${serverName}: ${JSON.stringify(Object.keys(enabled))}`
+      );
+      await this.addMcpServer(serverName, serverConfig);
+      for (const [toolName, v] of Object.entries(enabled)) {
+        assert(v === true);
+        this.mcpServerManager.enableTool(serverName, toolName);
+      }
+    }
+  }
+
+  /**
+   * Query backend for server list, clear tool cache.
+   */
+  public async refresh(): Promise<void> {
+    const servers = await this.apiClient.search([]);
+    const [mcpServers, mcpServersMap] = buildServersList(servers);
+    this.serverBriefs = mcpServers;
+    this.serverBriefsMap = mcpServersMap;
+    this.toolCache = {};
+  }
+
+  public getServerBriefs(): McpServerBrief[] {
+    return this.serverBriefs;
+  }
+
+  public getMcpServerManager(): McpServerManager {
+    return this.mcpServerManager;
+  }
+
+  /**
+   * Return tool list for a given MCP server. Queries the backend
+   * if necessary and caches the result.
+   */
+  public async getServerTools(serverName: string): Promise<Tool[]> {
+    // Check cache
+    let tools = this.toolCache[serverName];
+    if (tools) {
+      return tools;
+    }
+
+    // Query backend (using the original name)
+    const originalName = this.serverBriefsMap[serverName].originalName;
+    tools = await this.apiClient.listTools(originalName);
+    this.toolCache[serverName] = tools;
+    return tools;
+  }
+
+  /**
+   * Add a server to the `McpServerManager`, using `ApiClient`
+   * to produce the transport. Validates the server's config
+   * schema, if applicable.
+   */
+  public async addMcpServer(
+    serverName: string,
+    configuration: McpServerConfiguration | undefined
+  ): Promise<void> {
+    const tools = await this.getServerTools(serverName);
+    const originalName = this.serverBriefsMap[serverName].originalName;
+    const mcpserver = await this.apiClient.getDetails(originalName, "run");
+    verifyConfigForServer(mcpserver, configuration);
+    const client = new McpClient({
+      name: "@xalia/agent",
+      version: "1.0.0",
+    });
+    await connectServer(
+      client,
+      this.apiClient,
+      mcpserver,
+      configuration,
+      this.openUrl,
+      this.authorized_url
+    );
+    await this.mcpServerManager.addMcpServerWithClient(
+      client,
+      serverName,
+      tools
+    );
+  }
+
+  public getOriginalName(serverName: string): string {
+    return this.serverBriefsMap[serverName].name;
+  }
+}
+
+/**
+ * Connect a client to a hosted MCP server session,
+ * prompting for authentication if needed.
+ */
+async function connectServer(
+  client: McpClient,
+  apiClient: ApiClient,
+  mcpServer: McpServer,
+  config: McpServerConfiguration | undefined,
+  openUrl: (url: string) => void,
+  authorized_url?: string,
+  noRetry: boolean = false
+): Promise<void> {
+  const transport = apiClient.mcpSession(mcpServer, config ?? {});
+
+  await client.connect(transport).catch(async (e) => {
+    if (e instanceof AuthenticationRequired && !noRetry) {
+      logger.info("authentication required: " + e.msg);
+
+      const { url, authenticatedP } = await apiClient.authenticate(
+        mcpServer.name,
+        authorized_url
+      );
+      logger.info(`authenticate at url: ${url}`);
+      openUrl(url);
+      const authResult = await authenticatedP;
+      logger.info(`authResult: ${authResult}`);
+      if (!authResult) {
+        throw "authentication failed";
+      }
+      return connectServer(
+        client,
+        apiClient,
+        mcpServer,
+        config,
+        openUrl,
+        authorized_url,
+        true
+      );
+    } else {
+      throw e;
+    }
+  });
+}
+
+/**
+ * Given a list of`ServerBrief` objects, create the corresponding list and map
+ * of `SantiizedServerBrief` objects (namely, objects with sanitized names,
+ * holding the original name in a new field).
+ */
+function buildServersList(
+  serverList: McpServerBrief[]
+): [SanitizedServerBrief[], { [serverName: string]: SanitizedServerBrief }] {
+  const servers: SanitizedServerBrief[] = [];
+  const serversMap: { [serverName: string]: SanitizedServerBrief } = {};
+
+  for (const s of serverList) {
+    const ss = SanitizedServerBrief.fromServerBrief(s);
+    servers.push(ss);
+    serversMap[ss.name] = ss;
+  }
+
+  return [servers, serversMap];
+}
+
+function sanitizeName(name: string): string {
+  return name.replace("/", "_");
+}

package/src/test/imageLoad.test.ts

@@ -0,0 +1,14 @@
+import { expect } from "chai";
+import { loadImageB64OrUndefined } from "../files";
+import { strict as assert } from "assert";
+
+describe("Image loading", () => {
+  it("convert to data url", async function () {
+    const imageB64 = loadImageB64OrUndefined("frog.png");
+    // console.log(`imageB64: ${imageB64}`);
+
+    expect(imageB64).to.be.a("string");
+    assert(typeof imageB64 === "string");
+    expect(imageB64.startsWith("data:image/png;base64")).eql(true);
+  });
+});

package/src/test/mcpServerManager.test.ts

@@ -0,0 +1,98 @@
+import { expect } from "chai";
+import {
+  computeQualifiedName,
+  McpServerManager,
+  splitQualifiedName,
+} from "../mcpServerManager";
+
+// Handle automatically closing at the end of tests.
+
+let managers: { [name: string]: McpServerManager } = {};
+let idx = 0;
+
+function getMcpServerManager(): McpServerManager {
+  const tm = new McpServerManager();
+  const name = "mgr" + ++idx;
+  managers[name] = tm;
+  return tm;
+}
+
+async function shutdownAll() {
+  for (const [k, v] of Object.entries(managers)) {
+    console.log(`shutting down ${k}`);
+    await v.shutdown();
+  }
+  managers = {};
+}
+
+describe("McpServerManager", async () => {
+  it("should initialize with correct descriptions", async (): Promise<void> => {
+    const tm = getMcpServerManager();
+    await tm.addMcpServer(
+      "simplecalc",
+      "http://localhost:5001/mcpsession/sudomcp/simplecalc",
+      "dummy_key"
+    );
+
+    const server = tm.getMcpServer("simplecalc");
+    const availableTools = server.getTools();
+    expect(availableTools.length).greaterThan(0);
+
+    // Initially, no tools are enabled.
+    expect(tm.getOpenAITools().length).equal(0);
+
+    // Enable a tool and check we get a description for it.
+    const toolName = availableTools[0].name;
+    {
+      tm.enableTool("simplecalc", toolName);
+      const tools = tm.getOpenAITools();
+      expect(tools.length).greaterThan(0);
+      console.log(`tools: ${JSON.stringify(tools, undefined, 2)}`);
+    }
+
+    // Invoke
+    {
+      const qualifiedName = tm.getOpenAITools()[0].function.name;
+      const r = await tm.invoke(qualifiedName, { a: 1000, b: 10 });
+      console.log(`response: ${r}`);
+    }
+
+    // Disable and check we don't get the spec anymore
+    {
+      tm.disableTool("simplecalc", toolName);
+      const tools = tm.getOpenAITools();
+      expect(tools.length).equal(0);
+    }
+  }).timeout(10000);
+
+  it("qualified names", async () => {
+    const serverName = "server";
+    const toolName = "tool";
+    const qualifiedName = computeQualifiedName(serverName, toolName);
+
+    const [_serverName, _toolName] = splitQualifiedName(qualifiedName);
+
+    expect(_serverName).eql(serverName);
+    expect(_toolName).eql(toolName);
+  });
+
+  it("add / remove servers", async () => {
+    const tm = getMcpServerManager();
+
+    await tm.addMcpServer(
+      "simplecalc",
+      "http://localhost:5001/mcpsession/sudomcp/simplecalc",
+      "dummy_key"
+    );
+    tm.enableAllTools("simplecalc");
+    expect(tm.getOpenAITools().length).greaterThan(0);
+
+    // Remove server and check there is no server, and no openai entries.
+
+    await tm.removeMcpServer("simplecalc");
+    expect(tm.getOpenAITools().length).equal(0);
+    expect(() => {
+      tm.getMcpServer("simplecalc");
+    }).throws();
+  });
+}).afterAll(shutdownAll);

package/src/test/prompt.test.ts

@@ -0,0 +1,26 @@
+import { expect } from "chai";
+import { parsePrompt } from "../prompt";
+
+describe("Prompt", () => {
+  it("should recognise commands", async function () {
+    const expectedResults = {
+      "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 serverName toolName": {
+        msg: undefined,
+        cmds: ["e", "serverName", "toolName"],
+      },
+      ":ea serverName": {
+        msg: undefined,
+        cmds: ["ea", "serverName"],
+      },
+    };
+
+    for (const [prompt, expected] of Object.entries(expectedResults)) {
+      const res = parsePrompt(prompt);
+      expect(res).eql(expected);
+    }
+  });
+});

package/src/test/sudoMcpServerManager.test.ts

@@ -0,0 +1,63 @@
+import { expect } from "chai";
+import { McpServerManager } from "../mcpServerManager";
+import {
+  SudoMcpServerManager,
+  LOCAL_SERVER_URL,
+} from "../sudoMcpServerManager";
+import chalk from "chalk";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+
+let managers: [McpServerManager, SudoMcpServerManager] | undefined = undefined;
+
+async function getServerManagers(): Promise<
+  [McpServerManager, SudoMcpServerManager]
+> {
+  if (!managers) {
+    const tm = new McpServerManager();
+    const sm = await SudoMcpServerManager.initialize(
+      tm,
+      (_url: string) => {
+        throw "unexpected call to openUrl";
+      },
+      LOCAL_SERVER_URL,
+      "dummy_key"
+    );
+
+    managers = [tm, sm];
+  }
+
+  return managers;
+}
+
+async function shutdownAll() {
+  if (managers) {
+    await managers[0].shutdown();
+  }
+  managers = undefined;
+}
+
+describe("SudoMcpServerManager", async () => {
+  it("should fetch servers from deployed backend", async () => {
+    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 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();
+    await sm.addMcpServer("sudomcp_simplecalc", {});
+    const serverBriefs = sm.getServerBriefs();
+    expect(serverBriefs.some((brief) => brief.name === "sudomcp_simplecalc"));
+  }).timeout(20000);
+}).afterAll(shutdownAll);
+
+export function prettyPrintTool(tool: Tool): void {
+  console.log(`- ${chalk.green(tool.name)}:`);
+  console.log(`  ${chalk.italic(tool.description)}\n`);
+}

package/src/tokenAuth.ts

@@ -0,0 +1,50 @@
+import {
+  OAuthClientInformationFull,
+  OAuthClientMetadata,
+  OAuthTokens,
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+
+export class TokenAuth implements OAuthClientProvider {
+  token: string;
+
+  constructor(token: string) {
+    this.token = token;
+  }
+
+  get redirectUrl(): string {
+    throw "unimpl";
+  }
+  get clientMetadata(): OAuthClientMetadata {
+    throw "unimpl";
+  }
+
+  clientInformation(): undefined {
+    return undefined;
+  }
+
+  saveClientInformation?(
+    _clientInformation: OAuthClientInformationFull
+  ): void | Promise<void> {
+    throw "unimpl";
+  }
+
+  tokens(): OAuthTokens | undefined | Promise<OAuthTokens | undefined> {
+    return {
+      access_token: this.token,
+      token_type: "bearer",
+    };
+  }
+  saveTokens(_tokens: OAuthTokens): void | Promise<void> {
+    throw "unimpl";
+  }
+  redirectToAuthorization(_authorizationUrl: URL): void | Promise<void> {
+    throw "unimpl";
+  }
+  saveCodeVerifier(_codeVerifier: string): void | Promise<void> {
+    throw "unimpl";
+  }
+  codeVerifier(): string | Promise<string> {
+    throw "unimpl";
+  }
+}

package/src/tools.ts

@@ -0,0 +1,57 @@
+import OpenAI from "openai";
+
+export const temperatureTool: OpenAI.ChatCompletionTool = {
+  type: "function",
+  function: {
+    name: "getCurrentTemperature",
+    description: "Get the current temperature for a specific location",
+    parameters: {
+      type: "object",
+      properties: {
+        location: {
+          type: "string",
+          description: "The city and state, e.g., San Francisco, CA",
+        },
+        unit: {
+          type: "string",
+          enum: ["Celsius", "Fahrenheit"],
+          description:
+            "The temperature unit to use. Infer this from the user's location.",
+        },
+      },
+      required: ["location", "unit"],
+    },
+  },
+};
+
+interface TemperatureArgs {
+  location?: string;
+  unit?: string;
+}
+
+function isTemperatureArgs(args: unknown): args is TemperatureArgs {
+  return (
+    typeof args === "object" &&
+    args !== null &&
+    ("location" in args || "unit" in args)
+  );
+}
+
+// Handle non-MCP tools
+export const toolCallbacks: {
+  [toolName: string]: { (args: unknown): string };
+} = {
+  getCurrentTemperature: (args: unknown) => {
+    if (!isTemperatureArgs(args) || !args.location) {
+      return `Location required`;
+    }
+    return `The temperature in ${args.location} is 22 degrees ${args.unit}`;
+  },
+};
+
+export function displayToolCall(
+  toolCall: OpenAI.ChatCompletionMessageToolCall
+): void {
+  console.log(`AGENT: Tool Call: ${toolCall.function.name}`);
+  console.log(`       Args: ${toolCall.function.arguments}`);
+}

package/test_data/background_test_profile.json

@@ -0,0 +1,7 @@
+{
+  "NOTES": "Intended to be used by a script running in ../../mcppro/_test_background",
+  "llm_url": "../../agent/test_data/background_test_script.json",
+  "model": "dummy",
+  "system_prompt": "A test system prompt",
+  "mcp_settings": {}
+}

package/test_data/background_test_script.json

@@ -0,0 +1,11 @@
+[
+  {
+    "index": 0,
+    "message": {
+      "role": "assistant",
+      "content": "This is a generated message for testing purposes",
+      "tool_calls": []
+    },
+    "finish_reason": "stop"
+  }
+]

package/test_data/dummyllm_script_simplecalc.json

@@ -0,0 +1,28 @@
+[
+  {
+    "index": 0,
+    "message": {
+      "role": "assistant",
+      "content": "I'll help you divide those numbers. Let me calculate 12341543 divided by 431234132.",
+      "tool_calls": [
+        {
+          "id": "toolu_017umizET2MjAC2ir5t4iiVR",
+          "type": "function",
+          "function": {
+            "name": "sudomcp_simplecalc__divide",
+            "arguments": "{\"a\": 12341543, \"b\": 431234132}"
+          }
+        }
+      ]
+    },
+    "finish_reason": "tool_calls"
+  },
+  {
+    "index": 0,
+    "message": {
+      "role": "assistant",
+      "content": "The result of dividing 12341543 by 431234132 is approximately 0.0286 (or about 1/35)."
+    },
+    "finish_reason": "stop"
+  }
+]

package/test_data/git_message_profile.json

@@ -0,0 +1,4 @@
+{
+  "system_prompt": "Scan a code diff and produce concise and accurate commit messages.  The messages should be of the form:\n```\nfeat: added some feature\n```\nOR\n```\nfeat[component]: added some feature\n```\nand ideally be contained on a single line.  Instead of `feat`, `fix`, `wip` and `chore` are acceptable tags. Look at file paths and directories for clues regarding which components are being modified. NEVER explain any intermediate steps. Output ONLY the raw message.\n",
+  "mcp_settings": {}
+}

package/test_data/git_wip_system.txt

@@ -0,0 +1,5 @@
+Your job is to look at WIP code changes and create a brief but informative description of:
+- the high level code change being made
+- the parts that have been completed
+- suggestions for what should be tackled next
+I will read the description on Monday morning to refresh my memory.  I'll have forgotten some important details, but will still have the broad goals in mind (you can leverage this to keep the description short).  I want to get the context back into my mind as quickly as possible.

package/test_data/pr_message_profile.json

@@ -0,0 +1,4 @@
+{
+  "system_prompt": "Scan a set of git commits and generate a concise pull-request description.  If the PR covers multiple concepts, include a bullet list of the form:\n```\n- [ ] Add some feature to some component\n...\n```\nLeave the checkbox empty so the user can fill it in when complete.\nNEVER explain any intermediate steps. Output ONLY the raw message.\n",
+  "mcp_settings": {}
+}

package/test_data/pr_review_profile.json

@@ -0,0 +1,4 @@
+{
+  "system_prompt": "Scan a set of diffs and create a PR review with the following format:\n```\n## <filename>:<line-number>\n\n<description of the issue>\n\n```\n\nCheck for maintainability issues, unnecessary complexity etc.\n",
+  "mcp_settings": {}
+}

package/test_data/prompt_simplecalc.txt

@@ -0,0 +1 @@
+What is 12341543 divided by 431234132?

package/test_data/simplecalc_profile.json

@@ -0,0 +1,4 @@
+{
+  "system_prompt": "You are a helpful agent",
+  "mcp_settings": {"sudomcp_simplecalc":{"divide":true}}
+}

package/test_data/sudomcp_import_profile.json

@@ -0,0 +1,4 @@
+{
+  "system_prompt": "Your job is to parse the public README of an mcp server code repository and extract the commands to run the server. You must then create a yaml \"sudomcp\" spec of the form:\n```\nname: mongodb-local\ntitle: MongoDB Local\ndescription: Interact with a local MongoDB instance (via connection string)\nlogo_url: \"https://github.com/sudobase-ai/mcp-servers/blob/master/mongodb-local/logo.png?raw=true\"\nconfig_schema:\n  connection_string:\n    type: string\n    default: \"mongodb://localhost\"\nstdio_server_params:\n  command: \"npx\"\n  args:\n    - \"-y\"\n    - \"mongodb-mcp-server\"\n  env:\n    MDB_MCP_CONNECTION_STRING: $connection_string\n```\nThe above is for a mongodb MCP server, requiring an environment variable `MDB_MCP_CONNECTION_STRING`. The `config_schema` section determines the variables that are required from the user in order to populate the `args` or the `env` values. Each server will have its own configuration requirements and some servers will not require a `config_schema` section at all.  The use of \"mcp\" in the name, title and description is redundant and should be avoided.\n\nDo not explain any intermediate steps or give any justification.  Just output the yaml file directly so I can pipe it to a file.  No ``` or similar notation.\n\n",
+  "mcp_settings": {"duckduckgo-search":{"fetch_content":true}}
+}

package/test_data/test_script_profile.json

@@ -0,0 +1,9 @@
+{
+  "NOTES": "Intended to be used by the mcppro test_script",
+  "llm_url": "test_data/dummyllm_script_simplecalc.json",
+  "model": "dummy",
+  "system_prompt": "You are a helpful agent",
+  "mcp_settings": {
+    "sudomcp_simplecalc":{"add":true,"divide":true}
+  }
+}