@xalia/agent 0.5.0

package/src/mcpServerManager.ts

@@ -0,0 +1,371 @@
+import { ChatCompletionTool } from "openai/resources.mjs";
+import {
+  SSEClientTransport,
+  SSEClientTransportOptions,
+} from "@modelcontextprotocol/sdk/client/sse.js";
+import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { TokenAuth } from "./tokenAuth";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { strict as assert } from "assert";
+import { McpServerSettings, getLogger } from "@xalia/xmcp/sdk";
+export type { McpServerSettings } from "@xalia/xmcp/sdk";
+
+const logger = getLogger();
+
+/// Callback into an Mcp server
+export type McpCallback = { (args: string): Promise<string> };
+
+/// Map of tool name to callback
+export type McpCallbacks = { [toolName: string]: McpCallback };
+
+/// List of tool names that are enabled.  We keep it as a map in the runtime
+/// object, so that we can quickly add and remove arbitrary entries.  (The
+/// AgentProfile keeps this as a flat list).
+export type EnabledToolsMap = { [toolName: string]: boolean };
+
+/**
+ * The (read-only) McpServerInfo to expose to external classes.  Callers
+ * should not modify this data directly.  Only through the McpServerManager
+ * class.
+ */
+export class McpServerInfo {
+  private readonly tools: Tool[]; // TODO: May not need both tools and toolsMap
+  private readonly toolsMap: { [toolName: string]: Tool };
+  protected enabledToolsMap: EnabledToolsMap;
+
+  constructor(tools: Tool[]) {
+    const toolsMap: { [toolName: string]: Tool } = {};
+
+    for (const mcpTool of tools) {
+      const toolName = mcpTool.name;
+      toolsMap[toolName] = mcpTool;
+    }
+
+    this.tools = tools;
+    this.toolsMap = toolsMap;
+    this.enabledToolsMap = {};
+  }
+
+  public getEnabledTools(): EnabledToolsMap {
+    return this.enabledToolsMap;
+  }
+
+  public getTools(): Tool[] {
+    return this.tools;
+  }
+
+  public getTool(toolName: string): Tool {
+    return this.toolsMap[toolName];
+  }
+}
+
+/**
+ * The internal class holds server info and allows it to be updated. Managed
+ * by McpServerManager.  Do not access these methods except via the
+ * McpServerManager.
+ */
+class McpServerInfoInternal extends McpServerInfo {
+  private readonly client: McpClient;
+  private readonly callbacks: McpCallbacks;
+
+  constructor(client: McpClient, tools: Tool[]) {
+    super(tools);
+
+    const callbacks: McpCallbacks = {};
+
+    for (const mcpTool of tools) {
+      const toolName = mcpTool.name;
+
+      // Create callback
+      const callback = async (argStr: string): Promise<string> => {
+        logger.debug(
+          `cb for ${toolName} invoked with args (${typeof argStr}): ` +
+            `${JSON.stringify(argStr)}`
+        );
+
+        const argsObj = JSON.parse(argStr);
+        const toolResult = await client.callTool({
+          name: toolName,
+          arguments: argsObj,
+        });
+        logger.debug(
+          `cb for ${toolName} returned: ${JSON.stringify(toolResult)}`
+        );
+
+        assert(typeof toolResult === "object");
+        const content = toolResult.content as { [a: number]: unknown };
+        assert(typeof content === "object");
+        assert(content);
+        const content0 = content[0] as { text: string };
+        assert(typeof content0 === "object");
+        const content0Text = content0.text;
+        assert(typeof content0Text === "string");
+        return content0Text;
+      };
+
+      callbacks[toolName] = callback;
+    }
+
+    this.client = client;
+    this.callbacks = callbacks;
+  }
+
+  public async shutdown(): Promise<void> {
+    await this.client.close();
+  }
+
+  public enableTool(toolName: string) {
+    this.enabledToolsMap[toolName] = true;
+  }
+
+  public disableTool(toolName: string) {
+    delete this.enabledToolsMap[toolName];
+  }
+
+  public getCallback(toolName: string) {
+    return this.callbacks[toolName];
+  }
+}
+
+/**
+ * Manage a set of MCP servers, where the tools for each server have an
+ * 'enabled' flag.  Tools are disabled by default.  The set of enabled tools
+ * over all servers is exposed as a single list of OpenAI functions.
+ */
+export class McpServerManager {
+  private mcpServers: { [serverName: string]: McpServerInfoInternal } = {};
+  private enabledToolsDirty: boolean = true;
+  private enabledOpenAITools: ChatCompletionTool[] = [];
+
+  public async shutdown() {
+    await Promise.all(
+      Object.keys(this.mcpServers).map((name) => {
+        logger.debug(`shutting down: ${name}...`);
+        this.mcpServers[name].shutdown();
+      })
+    );
+
+    this.mcpServers = {};
+  }
+
+  public getMcpServerNames(): string[] {
+    return Object.keys(this.mcpServers);
+  }
+
+  public getMcpServer(mcpServerName: string): McpServerInfo {
+    return this.getMcpServerInternal(mcpServerName);
+  }
+
+  public async addMcpServer(
+    mcpServerName: string,
+    url: string,
+    apiKey?: string,
+    tools?: Tool[]
+  ): Promise<void> {
+    logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
+    const sseTransportOptions: SSEClientTransportOptions = {};
+    if (apiKey) {
+      sseTransportOptions.authProvider = new TokenAuth(apiKey);
+    }
+    const urlO = new URL(url);
+    const transport = new SSEClientTransport(urlO, sseTransportOptions);
+    const client = new McpClient({
+      name: "@xalia/agent",
+      version: "1.0.0",
+    });
+
+    try {
+      await client.connect(transport);
+    } catch (e) {
+      // TODO: is this catch necessary?
+      await client.close();
+      throw e;
+    }
+    await this.addMcpServerWithClient(client, mcpServerName, tools);
+  }
+
+  /**
+   * Add MCP server from an already connected McpClient.
+   */
+  public async addMcpServerWithClient(
+    client: McpClient,
+    mcpServerName: string,
+    tools?: Tool[]
+  ): Promise<void> {
+    try {
+      // TODO; require the tools to be passed in.
+
+      if (!tools) {
+        const mcpTools = await client.listTools();
+        tools = mcpTools.tools;
+      }
+
+      this.mcpServers[mcpServerName] = new McpServerInfoInternal(client, tools);
+    } catch (e) {
+      await client.close();
+      throw e;
+    }
+  }
+
+  public async removeMcpServer(mcpServerName: string) {
+    const server = this.getMcpServerInternal(mcpServerName);
+    delete this.mcpServers[mcpServerName];
+    await server.shutdown();
+    this.enabledToolsDirty = true;
+  }
+
+  public enableAllTools(mcpServerName: string) {
+    logger.debug(`enableAllTools: ${mcpServerName}`);
+    const server = this.getMcpServerInternal(mcpServerName);
+    for (const tool of server.getTools()) {
+      logger.debug(`enable: ${tool.name}`);
+      server.enableTool(tool.name);
+    }
+    this.enabledToolsDirty = true;
+  }
+
+  public disableAllTools(mcpServerName: string) {
+    logger.debug(`disableAllTools: ${mcpServerName}`);
+    const server = this.getMcpServerInternal(mcpServerName);
+    for (const tool of server.getTools()) {
+      logger.debug(`disable: ${tool.name}`);
+      server.disableTool(tool.name);
+    }
+    this.enabledToolsDirty = true;
+  }
+
+  public enableTool(mcpServerName: string, toolName: string) {
+    logger.debug(`enableTool: ${mcpServerName} ${toolName}`);
+    const server = this.getMcpServerInternal(mcpServerName);
+    server.enableTool(toolName);
+    this.enabledToolsDirty = true;
+  }
+
+  public disableTool(mcpServerName: string, toolName: string) {
+    const server = this.getMcpServerInternal(mcpServerName);
+    server.disableTool(toolName);
+    this.enabledToolsDirty = true;
+  }
+
+  public getOpenAITools(): ChatCompletionTool[] {
+    if (this.enabledToolsDirty) {
+      this.enabledOpenAITools = computeOpenAIToolList(this.mcpServers);
+      this.enabledToolsDirty = false;
+    }
+
+    return this.enabledOpenAITools;
+  }
+
+  /**
+   * Note the `qualifiedToolName` is the full `{mcpServerName}/{toolName}` as
+   * in the openai spec.
+   */
+  public async invoke(
+    qualifiedToolName: string,
+    args: unknown
+  ): Promise<string> {
+    const [mcpServerName, toolName] = splitQualifiedName(qualifiedToolName);
+    logger.debug(`invoke: qualified: ${qualifiedToolName}`);
+    logger.debug(
+      `invoke: mcpServerName: ${mcpServerName}, toolName: ${toolName}`
+    );
+    logger.debug(`invoke: args: ${JSON.stringify(args)}`);
+
+    const server = this.getMcpServerInternal(mcpServerName);
+    const cb = server.getCallback(toolName);
+    if (!cb) {
+      throw `Unknown tool ${qualifiedToolName}`;
+    }
+
+    return cb(JSON.stringify(args));
+  }
+
+  /**
+   * "Settings" refers to the set of added servers and enabled tools.
+   */
+  public getMcpServerSettings(): McpServerSettings {
+    const config: McpServerSettings = {};
+
+    // NOTE: on load, entires of the form:
+    //
+    //   <server>: []
+    //
+    // may be interpreted as "all tools for <server>".  If the client has left
+    // a server with no tools enabled, we mark it as disabled.
+
+    for (const [serverName, server] of Object.entries(this.mcpServers)) {
+      const tools = Object.keys(server.getEnabledTools());
+      if (tools.length > 0) {
+        config[serverName] = tools;
+      }
+    }
+
+    return config;
+  }
+
+  private getMcpServerInternal(mcpServerName: string): McpServerInfoInternal {
+    const server = this.mcpServers[mcpServerName];
+    if (server) {
+      return server;
+    }
+    throw Error(`unknown server ${mcpServerName}`);
+  }
+}
+
+export function computeQualifiedName(
+  mcpServerName: string,
+  toolName: string
+): string {
+  return `${mcpServerName}__${toolName}`;
+}
+
+export function splitQualifiedName(
+  qualifiedToolName: string
+): [string, string] {
+  const delimIdx = qualifiedToolName.indexOf("__");
+  if (delimIdx < 0) {
+    throw Error(`invalid qualified name: ${qualifiedToolName}`);
+  }
+
+  return [
+    qualifiedToolName.slice(0, delimIdx),
+    qualifiedToolName.slice(delimIdx + 2),
+  ];
+}
+
+export function computeOpenAIToolList(mcpServers: {
+  [mcpServer: string]: McpServerInfoInternal;
+}): ChatCompletionTool[] {
+  const openaiTools: ChatCompletionTool[] = [];
+
+  for (const mcpServerName in mcpServers) {
+    const mcpServer = mcpServers[mcpServerName];
+    const tools = mcpServer.getTools();
+    const enabled = mcpServer.getEnabledTools();
+
+    for (const mcpTool of tools) {
+      const toolName = mcpTool.name;
+      if (enabled[toolName]) {
+        const qualifiedName = computeQualifiedName(mcpServerName, toolName);
+        const openaiTool = mcpToolToOpenAITool(mcpTool, qualifiedName);
+        openaiTools.push(openaiTool);
+      }
+    }
+  }
+
+  return openaiTools;
+}
+
+export function mcpToolToOpenAITool(
+  tool: Tool,
+  qualifiedName?: string
+): ChatCompletionTool {
+  return {
+    type: "function",
+    function: {
+      name: qualifiedName || tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+    },
+  };
+}

package/src/nodePlatform.ts

@@ -0,0 +1,24 @@
+import * as fs from "fs";
+import { execSync } from "child_process";
+import { IPlatform } from "./iplatform";
+
+/**
+ * Implementation of the IPlatform interface for node.js
+ */
+export const NODE_PLATFORM: IPlatform = {
+  openUrl: (url: string) => {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      execSync(`open '${url}'`);
+    } else if (platform === "linux") {
+      execSync(`xdg-open '${url}'`);
+    } else if (platform === "win32") {
+      execSync(`start '${url}'`);
+    } else {
+      throw `Unknown platform ${platform}`;
+    }
+  },
+  load: async (filename: string): Promise<string> => {
+    return fs.readFileSync(filename, { encoding: "utf8" });
+  },
+};

package/src/openAILLM.ts

@@ -0,0 +1,51 @@
+import { ILLM } from "./llm";
+import { OpenAI } from "openai";
+
+export class OpenAILLM implements ILLM {
+  private readonly openai: OpenAI;
+  private model: string;
+
+  constructor(
+    apiKey: string,
+    apiUrl: string | undefined,
+    model: string | undefined
+  ) {
+    this.openai = new OpenAI({
+      apiKey,
+      baseURL: apiUrl,
+      dangerouslyAllowBrowser: true,
+    });
+    this.model = model || "gpt-4o-mini";
+  }
+
+  public setModel(model: string) {
+    this.model = model;
+  }
+
+  getModel(): string {
+    return this.model;
+  }
+
+  getUrl(): string {
+    return this.openai.baseURL;
+  }
+
+  public async getConversationResponse(
+    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
+    tools?: OpenAI.Chat.Completions.ChatCompletionTool[],
+    onMessage?: (msg: string, end: boolean) => Promise<void>
+  ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+    const completion = await this.openai.chat.completions.create({
+      model: this.model,
+      messages,
+      tools,
+    });
+    if (onMessage) {
+      const message = completion.choices[0].message;
+      if (message.content) {
+        await onMessage(message.content, true);
+      }
+    }
+    return completion;
+  }
+}