@xalia/agent 0.5.0

package/src/prompt.ts

@@ -0,0 +1,93 @@
+import readline from "readline";
+
+const DEFAULT_PROMPT: string = "USER: ";
+
+export class Prompt {
+  private line: string | undefined;
+  private online: { (line: string | undefined): void } | undefined;
+  // private onerror: { (reason?: any): void } | undefined;
+  private prompt: readline.Interface;
+
+  constructor() {
+    this.prompt = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: DEFAULT_PROMPT,
+    });
+
+    this.prompt.on("line", (line) => {
+      this.line = line;
+      this.resolve();
+    });
+    this.prompt.on("close", () => {
+      this.line = undefined;
+      this.resolve();
+    });
+  }
+
+  async run(prompt?: string): Promise<string | undefined> {
+    // Clear any line
+    this.line = "";
+
+    return new Promise<string | undefined>((r) => {
+      this.online = r;
+      if (prompt) {
+        this.prompt.setPrompt(prompt);
+      }
+      this.prompt.prompt();
+      if (prompt) {
+        this.prompt.setPrompt(DEFAULT_PROMPT);
+      }
+    });
+  }
+
+  shutdown(): void {
+    this.prompt.close();
+  }
+
+  private resolve(): void {
+    if (this.online) {
+      this.online(this.line);
+    }
+    this.online = undefined;
+  }
+}
+
+/**
+ * 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", ...])
+ */
+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/sudoMcpServerManager.ts

@@ -0,0 +1,278 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { McpServerManager, McpServerSettings } from "./mcpServerManager";
+import {
+  ApiClient,
+  McpServerBrief,
+  DEFAULT_SERVER_URL,
+  getLogger,
+  AuthenticationRequired,
+  EnabledToolsList,
+  McpServer,
+} from "@xalia/xmcp/sdk";
+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,
+      authResultP: Promise<boolean>,
+      displayName: 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,
+      authResultP: Promise<boolean>,
+      displayName: 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.listServers();
+
+    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: McpServerSettings
+  ): Promise<void> {
+    await this.restoreConfiguration(mcpSettings);
+  }
+
+  /**
+   * Load the configuration from sudomcp, and enable the specified tools.
+   */
+  public async restoreConfiguration(
+    mcpConfig: McpServerSettings
+  ): Promise<void> {
+    logger.debug("Restoring Mcp config");
+
+    // Concurrently establish all server connections
+    const addServer = async (serverName: string) => {
+      logger.debug(`restoring ${serverName} ...`);
+      return this.addMcpServer(serverName);
+    };
+    await Promise.all(Object.entries(mcpConfig).map((e) => addServer(e[0])));
+
+    // Enable tools
+    const enableTools = ([serverName, enabled]: [string, EnabledToolsList]) => {
+      // Migrate the old style: { [tool: string]: true } to the new list format
+      if (!(enabled instanceof Array)) {
+        enabled = Object.keys(enabled);
+      }
+      if (enabled.length === 0) {
+        logger.debug(` restoring "${serverName}": (all tools)`);
+        this.mcpServerManager.enableAllTools(serverName);
+        return;
+      }
+
+      logger.debug(` restoring "${serverName}": ${JSON.stringify(enabled)}`);
+      for (const toolName of enabled) {
+        this.mcpServerManager.enableTool(serverName, toolName);
+      }
+    };
+    Object.entries(mcpConfig).map((e) => enableTools(e));
+  }
+
+  /**
+   * Query backend for server list, clear tool cache.
+   */
+  public async refresh(): Promise<void> {
+    const servers = await this.apiClient.listServers();
+    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): Promise<void> {
+    const tools = await this.getServerTools(serverName);
+    const originalName = this.serverBriefsMap[serverName].originalName;
+    const mcpserver = await this.apiClient.getDetails(originalName, "run");
+    const client = new McpClient({
+      name: "@xalia/agent",
+      version: "1.0.0",
+    });
+    await connectServer(
+      client,
+      this.apiClient,
+      mcpserver,
+      this.openUrl,
+      this.authorized_url
+    );
+    await this.mcpServerManager.addMcpServerWithClient(
+      client,
+      serverName,
+      tools
+    );
+  }
+
+  public getOriginalName(serverName: string): string {
+    return this.serverBriefsMap[serverName].name;
+  }
+
+  public getApiClient(): ApiClient {
+    return this.apiClient;
+  }
+}
+
+/**
+ * Connect a client to a hosted MCP server session,
+ * prompting for authentication if needed.
+ */
+async function connectServer(
+  client: McpClient,
+  apiClient: ApiClient,
+  mcpServer: McpServer,
+  openUrl: (
+    url: string,
+    authResultP: Promise<boolean>,
+    displayName: string
+  ) => void,
+  authorized_url?: string,
+  noRetry: boolean = false
+): Promise<void> {
+  const transport = apiClient.mcpSession(mcpServer);
+
+  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, authenticatedP, mcpServer.title);
+      const authResult = await authenticatedP;
+      logger.info(`authResult: ${authResult}`);
+      if (!authResult) {
+        throw "authentication failed";
+      }
+      return connectServer(
+        client,
+        apiClient,
+        mcpServer,
+        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/mcpservers/sudomcp/simplecalc/session",
+      "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/mcpservers/sudomcp/simplecalc/session",
+      "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,65 @@
+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")
+    ).eql(true);
+  }).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,6 @@
+{
+  "NOTES": "Intended to be used by a script running in ../../mcppro/_test_background",
+  "model": "dummy:../../agent/test_data/background_test_script.json",
+  "system_prompt": "A test system prompt",
+  "mcp_settings": {}
+}