@xalia/agent 0.6.10 → 0.6.11

package/src/chat/client/sessionClient.ts

@@ -1,574 +0,0 @@
-import { Tool, Resource } from "@modelcontextprotocol/sdk/types.js";
-import { strict as assert } from "assert";
-import { v4 as uuidv4 } from "uuid";
-
-import {
-  AgentProfile,
-  McpServerBrief,
-  SavedAgentProfile,
-  getLogger,
-} from "@xalia/xmcp/sdk";
-
-import { ISkillManager } from "../../agent/sudoMcpServerManager";
-import {
-  McpServerInfo,
-  McpServerInfoRW,
-  ResourceContent,
-} from "../../agent/mcpServerManager";
-import { IConversation } from "../../agent/agent";
-import { MessageParam } from "../../agent/llm";
-
-import {
-  ClientSessionMessage,
-  ClientSessionMessageData,
-  ServerSessionScopedMessage,
-  ClientSetWorkspace,
-  ClientToServer,
-  isServerSessionFileMessage,
-} from "../protocol/messages";
-import { SessionParticipantMap } from "../data/dataModels";
-import { ISessionMessageSender } from "./interfaces";
-import { IMessageSender } from "./connection";
-import { SessionFiles } from "./sessionFiles";
-import { SessionFileDescriptor } from "../../agent/tools/fileManager";
-import { ResponseAwaiter } from "../utils/responseAwaiter";
-
-const logger = getLogger();
-
-class RemoteSudoMcpServerManager implements ISkillManager {
-  private sender: ISessionMessageSender;
-  private briefs: McpServerBrief[];
-  private briefsMap = new Map<string, McpServerBrief>();
-  private mcpServers = new Map<string, McpServerInfoRW>();
-
-  constructor(sender: ISessionMessageSender, briefs: McpServerBrief[]) {
-    this.sender = sender;
-    this.briefs = briefs;
-    briefs.forEach((b) => {
-      this.briefsMap.set(b.name, b);
-    });
-  }
-
-  hasMcpServer(mcpServerName: string): boolean {
-    return this.mcpServers.has(mcpServerName);
-  }
-
-  getMcpServerNames(): string[] {
-    return Array.from(this.mcpServers.keys());
-  }
-
-  getMcpServer(mcpServerName: string): McpServerInfo {
-    const server = this.mcpServers.get(mcpServerName);
-    if (server) {
-      return server;
-    }
-    throw Error(`[getMcpServer] unknown server ${mcpServerName}`);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async removeMcpServer(mcpServerName: string): Promise<void> {
-    if (!this.mcpServers.has(mcpServerName)) {
-      logger.info(
-        `[removeMcpServer] mcpServers: ${JSON.stringify(this.mcpServers)}`
-      );
-      throw Error(`no server ${mcpServerName} (removeMcpServer)`);
-    }
-
-    this.sender.sendSessionMessage({
-      type: "remove_mcp_server",
-      server_name: mcpServerName,
-    });
-  }
-
-  enableAllTools(mcpServerName: string): void {
-    if (!this.mcpServers.has(mcpServerName)) {
-      throw Error(`no server ${mcpServerName} (enableAllTools)`);
-    }
-
-    this.sender.sendSessionMessage({
-      type: "enable_all_mcp_server_tools",
-      server_name: mcpServerName,
-    });
-  }
-
-  disableAllTools(mcpServerName: string): void {
-    if (!this.mcpServers.has(mcpServerName)) {
-      throw Error(`no server ${mcpServerName} (disableAllTools)`);
-    }
-
-    this.sender.sendSessionMessage({
-      type: "disable_all_mcp_server_tools",
-      server_name: mcpServerName,
-    });
-  }
-
-  enableTool(mcpServerName: string, toolName: string): void {
-    const server = this.mcpServers.get(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.sendSessionMessage({
-      type: "enable_mcp_server_tool",
-      server_name: mcpServerName,
-      tool: toolName,
-    });
-  }
-
-  disableTool(mcpServerName: string, toolName: string): void {
-    const server = this.mcpServers.get(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.sendSessionMessage({
-      type: "disable_mcp_server_tool",
-      server_name: mcpServerName,
-      tool: toolName,
-    });
-  }
-
-  onMcpServerAdded(
-    mcpServerName: string,
-    tools: Tool[],
-    enabled_tools: string[],
-    resources: Resource[]
-  ) {
-    logger.debug(
-      `[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
-        `, enabled: ${JSON.stringify(enabled_tools)}`
-    );
-
-    const mcpServerInfo = new McpServerInfoRW(mcpServerName, tools, resources);
-    for (const tool of enabled_tools) {
-      mcpServerInfo.enableTool(tool);
-    }
-    this.mcpServers.set(mcpServerName, mcpServerInfo);
-  }
-
-  onMcpServerRemoved(mcpServerName: string) {
-    this.mcpServers.delete(mcpServerName);
-  }
-
-  onMcpServerToolEnabled(mcpServerName: string, toolName: string) {
-    const server = this.mcpServers.get(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.get(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);
-  }
-
-  getServerBriefs(): McpServerBrief[] {
-    return this.briefs;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async addMcpServer(server_name: string, enable_all: boolean): Promise<void> {
-    if (!this.briefsMap.has(server_name)) {
-      throw Error(`no such server ${server_name} (addMcpServer)`);
-    }
-
-    this.sender.sendSessionMessage({
-      type: "add_mcp_server",
-      server_name,
-      enable_all,
-    });
-  }
-
-  hasServer(server_name: string): boolean {
-    return this.briefsMap.has(server_name);
-  }
-
-  async shutdown(): Promise<void> {}
-}
-
-type ServerResponseMessages = Extract<
-  ServerSessionScopedMessage,
-  { client_message_id?: string }
->;
-
-export class SessionClient implements ISessionMessageSender, IConversation {
-  private readonly sessionUUID: string;
-  private readonly savedAgentProfile: SavedAgentProfile;
-  private readonly sender: IMessageSender<ClientToServer>;
-  private readonly smsm: RemoteSudoMcpServerManager;
-  private readonly sessionFiles: SessionFiles;
-  private readonly responseHandler: ResponseAwaiter<ServerResponseMessages>;
-  private participants: SessionParticipantMap;
-  private systemPrompt: string;
-  private model: string;
-  private agentPaused: boolean;
-
-  public constructor(
-    sessionUUID: string,
-    savedAgentProfile: SavedAgentProfile,
-    sender: IMessageSender<ClientToServer>,
-    serverBriefs: McpServerBrief[],
-    participants: SessionParticipantMap,
-    agentPaused: boolean
-  ) {
-    const fileList: SessionFileDescriptor[] = []; // Pass in?
-    this.sessionUUID = sessionUUID;
-    this.savedAgentProfile = savedAgentProfile;
-    this.sender = sender;
-    this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
-    this.sessionFiles = new SessionFiles(sessionUUID, fileList, sender);
-    this.responseHandler = ResponseAwaiter.init(
-      "session_error",
-      (msg: ServerResponseMessages) => msg.client_message_id
-    );
-    this.participants = participants;
-    this.systemPrompt = "";
-    this.model = "";
-    this.agentPaused = agentPaused;
-  }
-
-  public getSessionUUID(): string {
-    return this.sessionUUID;
-  }
-
-  /// This object can be queried to upload or download files, or get the
-  /// latest list. See `SessionFiles` for full usage.
-  public getSessionFiles(): SessionFiles {
-    return this.sessionFiles;
-  }
-
-  public getSudoMcpServerManager(): ISkillManager {
-    return this.smsm;
-  }
-
-  public getConversation(): MessageParam[] {
-    throw new Error("unimpl: getConversation");
-  }
-
-  public getAgentProfile(): AgentProfile {
-    return this.savedAgentProfile.profile;
-  }
-
-  public getAgentUuid(): string {
-    return this.savedAgentProfile.uuid;
-  }
-
-  getSavedAgentProfile(): SavedAgentProfile {
-    return this.savedAgentProfile;
-  }
-
-  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.sendSessionMessage({ 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.sendSessionMessage({ type: "set_model", model });
-  }
-
-  getAgentPaused(): boolean {
-    return this.agentPaused;
-  }
-
-  setAgentPaused(paused: boolean) {
-    this.sendSessionMessage({
-      type: "set_agent_paused",
-      paused,
-    });
-  }
-
-  async getMcpResource(
-    server_name: string,
-    uri: string
-  ): Promise<ResourceContent[]> {
-    const client_message_id = uuidv4();
-    const resourceP = this.responseHandler.waitForResponse(client_message_id);
-    this.sender.send({
-      type: "get_mcp_resource",
-      session_id: this.sessionUUID,
-      client_message_id,
-      server_name,
-      uri,
-    });
-
-    const resourceMsg = await resourceP;
-    if (resourceMsg.type !== "mcp_resource") {
-      throw new Error(
-        `unexpected response to resource req: ${JSON.stringify(resourceMsg)}`
-      );
-    }
-    return resourceMsg.contents;
-  }
-
-  userMessage(
-    msg?: string,
-    imageB64?: string,
-    attachedFiles?: { name: string; data_url: string }[]
-  ): void {
-    assert(
-      msg || imageB64 || (attachedFiles && attachedFiles.length > 0),
-      "Either message, image, or attachedFiles must be provided"
-    );
-
-    this.sendSessionMessage({
-      type: "msg",
-      message: msg,
-      imageB64,
-      attachedFiles,
-    });
-  }
-
-  userMessageRaceMode(model: string, msg?: string, imageB64?: string): void {
-    assert(msg || imageB64, "Either message or image must be provided");
-
-    this.sendSessionMessage({
-      type: "msg",
-      message: msg,
-      imageB64,
-      race_mode: model,
-    });
-  }
-
-  raceModeResult(result: string, message_id: string): void {
-    this.sendSessionMessage({
-      type: "race_mode_result",
-      result,
-      message_id,
-    });
-  }
-
-  stop(): void {
-    this.sendSessionMessage({
-      type: "stop",
-    });
-  }
-
-  resetConversation(): void {
-    throw new Error("resetConversation not implemented for ChatClient");
-  }
-
-  shutdown(): Promise<void> {
-    throw new Error("shutdown not implemented for ChatClient");
-  }
-
-  getParticipants(): SessionParticipantMap {
-    return this.participants;
-  }
-
-  /**
-   * Sets auto-approval preference for a specific tool.
-   */
-  setAutoApproval(
-    serverName: string,
-    toolName: string,
-    autoApprove: boolean
-  ): void {
-    const smsm = this.getSudoMcpServerManager();
-    if (!smsm.hasMcpServer(serverName)) {
-      throw Error(`server ${serverName} not added (setAutoApproval)`);
-    }
-    const server = smsm.getMcpServer(serverName);
-    const tool = server.getTool(toolName);
-    if (!tool) {
-      throw Error(`no tool ${toolName} on server ${serverName}`);
-    }
-
-    this.sendSessionMessage({
-      type: "set_auto_approval",
-      server_name: serverName,
-      tool: toolName,
-      auto_approve: autoApprove,
-    });
-  }
-
-  /**
-   * Send a generic message (for compatibility)
-   */
-  public sendMessage(message: { type: string; message: string }): void {
-    throw new Error(`Unsupported message type: ${message.type}`);
-  }
-
-  /**
-   * The caller sees a message `ServerApproveToolCall`, at which point it
-   * should prompt the user for permission to run the tool. The result of
-   * that prompt should be passed here.
-   */
-  toolCallApprovalResult(
-    id: string,
-    result: boolean,
-    auto_approve: boolean
-  ): void {
-    this.sendSessionMessage({
-      type: "tool_call_approval_result",
-      id,
-      result,
-      auto_approve,
-    });
-  }
-
-  // Implementation of IMessageSender interface
-  public sendSessionMessage(message: ClientSessionMessageData): void {
-    const enrichedMessage: ClientSessionMessage = {
-      ...message,
-      client_message_id: uuidv4(),
-      session_id: this.sessionUUID,
-    };
-
-    this.sender.send(enrichedMessage);
-  }
-
-  public setWorkspace(
-    message: string | undefined,
-    imageB64: string | undefined
-  ): void {
-    const msg: ClientSetWorkspace = {
-      type: "set_workspace",
-      message,
-      imageB64,
-    };
-    this.sendSessionMessage(msg);
-  }
-
-  /**
-   * Set MCP server configuration.
-   */
-  public setMcpServerConfig(
-    server_name: string,
-    config: Record<string, string>
-  ): void {
-    this.sendSessionMessage({
-      type: "set_mcp_server_config",
-      server_name,
-      config,
-    });
-  }
-
-  public deleteMcpServerConfig(server_name: string): void {
-    this.sendSessionMessage({
-      type: "set_mcp_server_config",
-      server_name,
-    });
-  }
-
-  public async shareSession(): Promise<string> {
-    const msg: ClientToServer = {
-      type: "share_session",
-      client_message_id: uuidv4(),
-      session_id: this.sessionUUID,
-    };
-
-    this.sender.send(msg);
-    const response = await this.responseHandler.waitForResponse(
-      msg.client_message_id
-    );
-    if (response.type === "session_shared") {
-      return response.access_token;
-    }
-
-    throw new Error(`unexpected response to "share"session": ${response.type}`);
-  }
-
-  handleMessage(message: ServerSessionScopedMessage): void {
-    if (isServerSessionFileMessage(message)) {
-      this.sessionFiles.onMessage(message);
-      return;
-    }
-
-    switch (message.type) {
-      //
-      // State updates
-      //
-
-      case "mcp_server_added":
-        this.smsm.onMcpServerAdded(
-          message.server_name,
-          message.tools,
-          message.enabled_tools,
-          message.resources
-        );
-        break;
-      case "mcp_server_removed":
-        this.smsm.onMcpServerRemoved(message.server_name);
-        break;
-      case "mcp_server_tool_enabled":
-        this.smsm.onMcpServerToolEnabled(message.server_name, message.tool);
-        break;
-      case "mcp_server_tool_disabled":
-        this.smsm.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;
-      case "session_info":
-        // This is handled in the layer above, in the chatClient
-        break;
-      case "user_added":
-        this.participants.set(message.user_uuid, {
-          user_uuid: message.user_uuid,
-          nickname: message.nickname,
-          email: message.email,
-          role: message.role,
-        });
-        break;
-      case "user_removed":
-        this.participants.delete(message.user_uuid);
-        break;
-
-      // Responses to requests which can be awaited
-      case "mcp_resource":
-      case "session_shared":
-        this.responseHandler.onMessage(message);
-        break;
-
-      case "agent_paused":
-        this.agentPaused = message.paused;
-        break;
-
-      //
-      // Ignore other messages - the owner (the UI layer) can handle them at
-      // its discretion.
-      //
-
-      default:
-        logger.debug(
-          `[handleMessageInternal]: ignoring message: ${message.type}`
-        );
-        break;
-    }
-  }
-}

package/src/chat/client/sessionFiles.ts

@@ -1,142 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { strict as assert } from "assert";
-
-import { getLogger } from "@xalia/xmcp/sdk";
-import { SessionFileDescriptor } from "../../agent/tools/fileManager";
-import {
-  ClientToServer,
-  ServerSessionFileContent,
-  ServerSessionFileMessage,
-} from "../protocol/messages";
-import { IMessageSender } from "./connection";
-import { ResponseAwaiter } from "../utils/responseAwaiter";
-
-const logger = getLogger();
-
-/// Object for the UI to use to interact with the FileManager.  If the UI
-/// receives ServerSessionFileChanged or ServerSessionFileDeleted then it
-/// should call `listFiles()` to get the new list of files, and optionally
-/// request the latest content via `getFileContent`.
-export class SessionFiles {
-  readonly sessionUUID: string;
-  readonly descriptors: Map<string, SessionFileDescriptor>;
-  readonly responseHandler: ResponseAwaiter<ServerSessionFileContent>;
-  readonly sender: IMessageSender<ClientToServer>;
-
-  constructor(
-    sessionUUID: string,
-    initialFileList: SessionFileDescriptor[],
-    sender: IMessageSender<ClientToServer>
-  ) {
-    this.sessionUUID = sessionUUID;
-    this.descriptors = new Map(initialFileList.map((d) => [d.name, d]));
-    this.responseHandler = ResponseAwaiter.init(
-      undefined,
-      (msg) => msg.client_message_id
-    );
-    this.sender = sender;
-  }
-
-  listFiles(): SessionFileDescriptor[] {
-    return Array.from(this.descriptors.values());
-  }
-
-  /**
-   * Retrieve file contents.
-   */
-  async getFileContent(name: string): Promise<string> {
-    const msg: ClientToServer = {
-      type: "session_file_get_content",
-      session_id: this.sessionUUID,
-      name,
-      client_message_id: uuidv4(),
-    };
-    this.sender.send(msg);
-    const response = await this.responseHandler.waitForResponse(
-      msg.client_message_id
-    );
-    if (response.name !== name) {
-      throw new Error(
-        `invalid name for file ${name}: ${JSON.stringify(response)}`
-      );
-    }
-    return response.data_url;
-  }
-
-  deleteFile(name: string): void {
-    const msg: ClientToServer = {
-      type: "session_file_delete",
-      session_id: this.sessionUUID,
-      name,
-      client_message_id: uuidv4(),
-    };
-    this.sender.send(msg);
-  }
-
-  putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): void {
-    // TODO: eventually, we could wait for a response which includes an AI
-    // assigned name.
-    assert(name, "for now, uploaded content must have a name");
-
-    const msg: ClientToServer = {
-      type: "session_file_put_content",
-      session_id: this.sessionUUID,
-      name,
-      summary,
-      data_url,
-      client_message_id: uuidv4(),
-    };
-    this.sender.send(msg);
-  }
-
-  onMessage(msg: ServerSessionFileMessage) {
-    logger.debug(`[SessionFiles.onMessage]: msg: ${JSON.stringify(msg)}`);
-    switch (msg.type) {
-      case "session_file_changed":
-        this.descriptors.set(msg.descriptor.name, msg.descriptor);
-        break;
-
-      case "session_file_deleted":
-        this.descriptors.delete(msg.name);
-        break;
-
-      case "session_file_content":
-        this.responseHandler.onMessage(msg);
-        break;
-
-      default: {
-        const _: never = msg;
-        const msgStr = JSON.stringify(msg);
-        throw new Error(`[SessionFiles.onMessage] invalid message: ${msgStr}`);
-      }
-    }
-  }
-
-  decodeSessionFileUrl(url: string): {
-    session_uuid: string;
-    name: string;
-  } {
-    const u = new URL(url);
-    if (u.protocol !== "file+session:") {
-      throw new Error(`unexpected protocol ${u.protocol} (file+session)`);
-    }
-    if (u.port || u.search || u.hash) {
-      throw new Error("badly formed session file url: ${url}");
-    }
-    return {
-      session_uuid: u.host || this.sessionUUID,
-      name: removeLeadingSlashes(u.pathname),
-    };
-  }
-}
-
-function removeLeadingSlashes(name: string): string {
-  while (name.startsWith("/")) {
-    name = name.slice(1);
-  }
-  return name;
-}