@xalia/agent 0.5.7 → 0.6.0

package/dist/agent/src/chat/server.js

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-// -*- typescript -*-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runServer = runServer;
-const dotenv = __importStar(require("dotenv"));
-const sdk_1 = require("@xalia/xmcp/sdk");
-const ws = __importStar(require("ws"));
-const url_1 = require("url");
-const conversationManager_1 = require("./conversationManager");
-const db_1 = require("./db");
-const apiKeyManager_1 = require("./apiKeyManager");
-dotenv.config();
-const logger = (0, sdk_1.getLogger)();
-/**
- * Try as id, then by user/name and return the AgentProfile uuid.
- */
-async function resolveAgentProfileId(db, userData, agentProfileIdentifier) {
-    let ap = await db.getSavedAgentProfileById(agentProfileIdentifier);
-    logger.debug(`[resolveAgentProfileId]: by id: {JSON.stringify(ap)}`);
-    if (ap) {
-        return agentProfileIdentifier;
-    }
-    ap = await db.getSavedAgentProfileByName(userData.uuid, agentProfileIdentifier);
-    logger.debug(`[resolveAgentProfileId]: by name: {JSON.stringify(ap)}`);
-    if (ap) {
-        return ap.uuid;
-    }
-    logger.debug("[resolveAgentProfileId]: agent profile not found");
-    return undefined;
-}
-async function resolveSessionIdFromIdentifier(db, userData, sessionIdentifier) {
-    let session = undefined;
-    const compound = (0, db_1.resolveCompoundName)(sessionIdentifier);
-    if (typeof compound === "string") {
-        // Interpret as an id, or as a number under the current user.
-        session = await db.getSessionById(compound);
-        if (!session) {
-            session = await db.getSessionByName(userData.uuid, compound);
-        }
-    }
-    else {
-        session = await db.getSessionByName(compound[0], compound[1]);
-    }
-    return session?.uuid;
-}
-/**
- * Expect parameters to be either:
- *   session_id                  - uuid, name, user/name
- *   agent_profile_id (optional) - uuid, name
- *
- * If session_idd resolves to an existing session, it is used (and
- * agent_profile_id is ignored).  Otherwise, session_id is used as the name of
- * a new session to create using `agent_profile_id`.  The session UUID is
- * returned in either case.
- */
-async function findOrCreateSession(db, userData, query) {
-    logger.debug(`[findOrCreateSession]: query: ${JSON.stringify(query)}`);
-    if (!query.session_id || typeof query.session_id !== "string") {
-        throw "session_id invalid or not present";
-    }
-    const sessionId = await resolveSessionIdFromIdentifier(db, userData, query.session_id);
-    if (sessionId) {
-        return sessionId;
-    }
-    const agentProfileIdParam = query.agent_profile_id;
-    logger.debug(`[findOrCreateSession]: agent: ${agentProfileIdParam}`);
-    if (!agentProfileIdParam) {
-        throw "no existing session, and no agent_profile_id given";
-    }
-    if (typeof agentProfileIdParam !== "string") {
-        throw "no existing session and invalid agent_profile_id";
-    }
-    logger.debug(`[findOrCreateSession]: creating session: ${query.session_id}`);
-    const agentProfileId = await resolveAgentProfileId(db, userData, agentProfileIdParam);
-    logger.debug(`[findOrCreateSession]: resolved agentProfileId: ${agentProfileId}`);
-    if (!agentProfileId) {
-        throw `no agent profile: ${agentProfileIdParam}`;
-    }
-    return db.createSession(userData.uuid, query.session_id, agentProfileId);
-}
-async function runServer(port, supabaseUrl, supabaseKey, llmUrl, xmcpUrl) {
-    return new Promise((r, _e) => {
-        const wss = new ws.Server({ port });
-        const db = new db_1.Database(supabaseUrl, supabaseKey);
-        const apiKeyManager = new apiKeyManager_1.ApiKeyManager(db);
-        const cm = new conversationManager_1.ConversationManager(db, llmUrl, xmcpUrl);
-        wss.on("connection", async (ws, req) => {
-            try {
-                logger.info(`[server] connection: ${req}`);
-                // Check header
-                logger.info(`[server] headers: ${JSON.stringify(req.headers)}`);
-                const apiKey = req.headers["sec-websocket-protocol"];
-                if (!apiKey) {
-                    throw "empty api key";
-                }
-                const userData = await apiKeyManager.verifyApiKey(apiKey);
-                if (!userData) {
-                    throw "invalid api key";
-                }
-                // Get sessionId
-                const { query } = (0, url_1.parse)(req.url || "", true);
-                const sessionId = await findOrCreateSession(db, userData, query);
-                logger.debug(`resolved session id: ${sessionId}`);
-                if (!sessionId) {
-                    throw "failed to find/create session";
-                }
-                // Associate the ws, username with the conversation
-                await cm.join(sessionId, apiKey, apiKey, userData, ws);
-            }
-            catch (e) {
-                if (typeof e === "string") {
-                    logger.warn(`[server]: error: ${e}`);
-                    ws.close(4000, e);
-                }
-                else {
-                    logger.error(`other error: ${JSON.stringify(e)}`);
-                    throw e;
-                }
-            }
-        });
-        logger.info(`[server] started: ws://localhost:${port}/`);
-        r(wss);
-    });
-}

package/src/chat/client.ts

@@ -1,455 +0,0 @@
-import { Tool } from "@modelcontextprotocol/sdk/types.js";
-import { strict as assert } from "assert";
-import * as websocket from "ws";
-
-import { AgentProfile, McpServerBrief, getLogger } from "@xalia/xmcp/sdk";
-
-import { ISkillManager } from "../agent/sudoMcpServerManager";
-import {
-  IMcpServerManager,
-  McpServerInfo,
-  McpServerInfoRW,
-} from "../agent/mcpServerManager";
-
-import { ServerToClient, ClientToServer } from "./messages";
-import { ChatCompletionMessageParam, IConversation } from "../agent/agent";
-import { IPlatform } from "../agent/iplatform";
-
-const logger = getLogger();
-
-type OnMessageCallback = (msg: ServerToClient) => void;
-
-type OnConnectionClosedCallback = () => Promise<void>;
-
-interface IMessageSender {
-  sendMessage(message: ClientToServer): void;
-}
-
-class RemoteMcpServerManager implements IMcpServerManager {
-  private mcpServers: { [serverName: string]: McpServerInfoRW } = {};
-
-  constructor(private sender: IMessageSender) {
-    this.mcpServers = {};
-  }
-
-  hasMcpServer(mcpServerName: string): boolean {
-    return !!this.mcpServers[mcpServerName];
-  }
-
-  getMcpServerNames(): string[] {
-    return Object.keys(this.mcpServers);
-  }
-
-  getMcpServer(mcpServerName: string): McpServerInfo {
-    const server = this.mcpServers[mcpServerName];
-    if (server) {
-      return server;
-    }
-    throw Error(`unknown server ${mcpServerName}`);
-  }
-
-  async removeMcpServer(mcpServerName: string): Promise<void> {
-    if (!this.mcpServers[mcpServerName]) {
-      throw Error(`no server ${mcpServerName} (removeMcpServer)`);
-    }
-
-    this.sender.sendMessage({
-      type: "remove_mcp_server",
-      server_name: mcpServerName,
-    });
-  }
-
-  enableAllTools(mcpServerName: string): void {
-    if (!this.mcpServers[mcpServerName]) {
-      throw Error(`no server ${mcpServerName} (enableAllTools)`);
-    }
-
-    this.sender.sendMessage({
-      type: "enable_all_mcp_server_tools",
-      server_name: mcpServerName,
-    });
-  }
-
-  disableAllTools(mcpServerName: string): void {
-    if (!this.mcpServers[mcpServerName]) {
-      throw Error(`no server ${mcpServerName} (disableAllTools)`);
-    }
-
-    this.sender.sendMessage({
-      type: "disable_all_mcp_server_tools",
-      server_name: mcpServerName,
-    });
-  }
-
-  enableTool(mcpServerName: string, toolName: string): void {
-    const server = this.mcpServers[mcpServerName];
-    if (!server) {
-      throw Error(`no server ${mcpServerName} (enableTool)`);
-    }
-    const tools = server.getTool(toolName);
-    if (!tools) {
-      throw Error(`no tool ${toolName} on server ${mcpServerName}`);
-    }
-
-    this.sender.sendMessage({
-      type: "enable_mcp_server_tool",
-      server_name: mcpServerName,
-      tool: toolName,
-    });
-  }
-
-  disableTool(mcpServerName: string, toolName: string): void {
-    const server = this.mcpServers[mcpServerName];
-    if (!server) {
-      throw Error(`no server ${mcpServerName} (disableTool)`);
-    }
-    const tools = server.getTool(toolName);
-    if (!tools) {
-      throw Error(`no tool ${toolName} on server ${mcpServerName}`);
-    }
-
-    this.sender.sendMessage({
-      type: "disable_mcp_server_tool",
-      server_name: mcpServerName,
-      tool: toolName,
-    });
-  }
-
-  onMcpServerAdded(
-    mcpServerName: string,
-    tools: Tool[],
-    enabled_tools: string[]
-  ) {
-    logger.debug(
-      `[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
-        `, enabled: ${JSON.stringify(enabled_tools)}`
-    );
-
-    const mcpServerInfo = new McpServerInfoRW(tools);
-    for (const tool of enabled_tools) {
-      mcpServerInfo.enableTool(tool);
-    }
-    this.mcpServers[mcpServerName] = mcpServerInfo;
-  }
-
-  onMcpServerRemoved(mcpServerName: string) {
-    delete this.mcpServers[mcpServerName];
-  }
-
-  onMcpServerToolEnabled(mcpServerName: string, toolName: string) {
-    const server = this.mcpServers[mcpServerName];
-    if (!server) {
-      throw Error(`no server ${mcpServerName} (onMcpServerToolEnabled)`);
-    }
-    const tools = server.getTool(toolName);
-    if (!tools) {
-      throw Error(`no tool ${toolName} on server ${mcpServerName}`);
-    }
-
-    server.enableTool(toolName);
-  }
-
-  onMcpServerToolDisabled(mcpServerName: string, toolName: string) {
-    const server = this.mcpServers[mcpServerName];
-    if (!server) {
-      throw Error(`no server ${mcpServerName} (onMcpServerToolDisabled)`);
-    }
-    const tools = server.getTool(toolName);
-    if (!tools) {
-      throw Error(`no tool ${toolName} on server ${mcpServerName}`);
-    }
-
-    server.disableTool(toolName);
-  }
-}
-
-class RemoteSudoMcpServerManager implements ISkillManager {
-  private briefsMap: Record<string, McpServerBrief>;
-
-  constructor(
-    private sender: IMessageSender,
-    private briefs: McpServerBrief[],
-    private msm: RemoteMcpServerManager
-  ) {
-    this.briefsMap = {};
-    briefs.forEach((b) => {
-      this.briefsMap[b.name] = b;
-    });
-  }
-
-  getMcpServerManager(): IMcpServerManager {
-    return this.msm;
-  }
-
-  getServerBriefs(): McpServerBrief[] {
-    return this.briefs;
-  }
-
-  async addMcpServer(server_name: string, enable_all: boolean): Promise<void> {
-    if (!this.briefsMap[server_name]) {
-      throw Error(`no such server ${server_name} (addMcpServer)`);
-    }
-
-    this.sender.sendMessage({
-      type: "add_mcp_server",
-      server_name,
-      enable_all,
-    });
-  }
-}
-
-export class ChatClient implements IMessageSender, IConversation {
-  private platform: IPlatform;
-  private ws: websocket.WebSocket;
-  private onMessageCB: OnMessageCallback;
-  private onConnectionClosedCB: OnConnectionClosedCallback;
-  private closed: boolean;
-  private msm: RemoteMcpServerManager;
-  private smsm: RemoteSudoMcpServerManager;
-  private systemPrompt: string;
-  private model: string;
-
-  private constructor(
-    platform: IPlatform,
-    ws: websocket.WebSocket,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback,
-    serverBriefs: McpServerBrief[]
-  ) {
-    this.platform = platform;
-    this.ws = ws;
-    this.onMessageCB = onMessageCB;
-    this.onConnectionClosedCB = onConnectionClosedCB;
-    this.closed = false;
-    this.msm = new RemoteMcpServerManager(this);
-    this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs, this.msm);
-    this.systemPrompt = "";
-    this.model = "";
-  }
-
-  static async initWithParams(
-    host: string,
-    port: number,
-    token: string,
-    params: Record<string, string>,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback,
-    platform: IPlatform
-  ): Promise<ChatClient> {
-    return new Promise((resolveClient, e) => {
-      const urlParams = new URLSearchParams(params);
-      const url = `ws://${host}:${port}?${urlParams}`;
-
-      const ws = new websocket.WebSocket(url, [token]);
-      logger.info("created ws");
-
-      let client: ChatClient | undefined = undefined;
-      const onMsg = (msg: ServerToClient) => {
-        if (msg.type === "mcp_server_briefs") {
-          // This should be received once, as the first message at startup.
-          assert(!client);
-          client = new ChatClient(
-            platform,
-            ws,
-            onMessageCB,
-            onConnectionClosedCB,
-            msg.server_briefs
-          );
-          resolveClient(client);
-        } else {
-          assert(client);
-
-          // Pass all messages to our internal handler (to update mcp state,
-          // etc) before sending to the client code.
-
-          // logger.debug(`[ChatClient.init(onMsg)]: ${JSON.stringify(msg)}`);
-          client.handleMessageInternal(msg);
-          client.onMessageCB(msg);
-        }
-      };
-
-      ws.onopen = async () => {
-        logger.info("opened");
-
-        ws.onmessage = (ev: websocket.MessageEvent) => {
-          try {
-            const msgData = ev.data;
-            if (typeof msgData !== "string") {
-              throw `expected "string" data, got ${typeof msgData}`;
-            }
-            logger.debug(`[client.onmessage]: ${msgData}`);
-            onMsg(JSON.parse(msgData) as ServerToClient);
-          } catch (e) {
-            if (client) {
-              client.close();
-            }
-            throw e;
-          }
-        };
-      };
-
-      ws.onclose = async (err) => {
-        logger.info("closed");
-        logger.info(
-          `[client] WebSocket connection closed: ${JSON.stringify(err)}`
-        );
-        if (client) {
-          client.closed = true;
-        }
-        await onConnectionClosedCB();
-      };
-
-      ws.onerror = async (error) => {
-        logger.error("[client] WebSocket error:", JSON.stringify(error));
-        e(error);
-
-        if (client) {
-          client.closed = true;
-        }
-        await onConnectionClosedCB();
-      };
-    });
-  }
-
-  public static async init(
-    host: string,
-    port: number,
-    token: string,
-    onMessageCB: OnMessageCallback,
-    onConnectionClosedCB: OnConnectionClosedCallback,
-    platform: IPlatform,
-    sessionId: string = "untitled",
-    agentProfileId: string | undefined = undefined
-  ): Promise<ChatClient> {
-    const params: Record<string, string> = { session_id: sessionId };
-    if (agentProfileId) {
-      params["agent_profile_id"] = agentProfileId;
-    }
-    return ChatClient.initWithParams(
-      host,
-      port,
-      token,
-      params,
-      onMessageCB,
-      onConnectionClosedCB,
-      platform
-    );
-  }
-
-  public getSudoMcpServerManager(): ISkillManager {
-    return this.smsm;
-  }
-
-  public getConversation(): ChatCompletionMessageParam[] {
-    throw "unimpl";
-  }
-
-  public getAgentProfile(): AgentProfile {
-    throw "unimpl";
-  }
-
-  getSystemPrompt(): string {
-    return this.systemPrompt;
-  }
-
-  setSystemPrompt(system_prompt: string): void {
-    // Don't set system prompt here.  Wait until we get confirmation from the
-    // server.
-    this.sendMessage({ type: "set_system_prompt", system_prompt });
-  }
-
-  getModel(): string {
-    return this.model;
-  }
-
-  setModel(model: string): void {
-    // Don't set model here.  Wait until we get confirmation from the server.
-    this.sendMessage({ type: "set_model", model });
-  }
-
-  userMessage(msg?: string, imageB64?: string): void {
-    assert(msg);
-    assert(!imageB64, "images not supported in Chat yet");
-
-    this.sendMessage({
-      type: "msg",
-      message: msg,
-    });
-  }
-
-  resetConversation(): void {
-    throw "resetConversation not implemented for ChatClient";
-  }
-
-  public sendMessage(message: ClientToServer): undefined {
-    assert(!this.closed);
-    const data = JSON.stringify(message);
-    logger.debug(`[ChatClient.sendMessage] ${data}`);
-    this.ws.send(data);
-  }
-
-  public close(): void {
-    this.closed = true;
-    this.onConnectionClosedCB();
-    this.ws.close();
-  }
-
-  handleMessageInternal(message: ServerToClient): void {
-    switch (message.type) {
-      //
-      // State updates
-      //
-
-      case "mcp_server_added":
-        this.msm.onMcpServerAdded(
-          message.server_name,
-          message.tools,
-          message.enabled_tools
-        );
-        break;
-      case "mcp_server_removed":
-        this.msm.onMcpServerRemoved(message.server_name);
-        break;
-      case "mcp_server_tool_enabled":
-        this.msm.onMcpServerToolEnabled(message.server_name, message.tool);
-        break;
-      case "mcp_server_tool_disabled":
-        this.msm.onMcpServerToolDisabled(message.server_name, message.tool);
-        break;
-      case "system_prompt_updated":
-        this.systemPrompt = message.system_prompt;
-        break;
-      case "model_updated":
-        this.model = message.model;
-        break;
-
-      //
-      // Actions
-      //
-
-      case "open_url":
-        this.platform.openUrl(
-          message.url,
-          new Promise(() => {}), // TODO: Why do we need this?  Remove it.
-          message.display_name
-        );
-        break;
-      case "approve_tool_call":
-        throw "unimpl approve_tool_call";
-      // break;
-
-      //
-      // Ignore other messages - the owner (the UI layer) can handle them at
-      // its discretion.
-      //
-
-      default:
-        logger.debug(
-          `[handleMessageInternal]: ignoring message: ${message.type}`
-        );
-        break;
-    }
-  }
-}
-
-// TODO: remove this