@xalia/agent 0.6.9 → 0.6.11

package/src/chat/server/openSessionMessageSender.ts

@@ -1,4 +0,0 @@
-export interface ISessionMessageSender<Msg> {
-  broadcast(msg: Msg): void;
-  sendTo(userUUID: string, msg: Msg): void;
-}

package/src/chat/server/server.ts

@@ -1,175 +0,0 @@
-#!/usr/bin/env node
-// -*- typescript -*-
-
-import * as dotenv from "dotenv";
-import { getLogger } from "@xalia/xmcp/sdk";
-import { WebSocketServer } from "ws";
-import * as ws from "ws";
-import { IncomingMessage } from "http";
-import { ConnectionManager, IUserConnectionManager } from "./connectionManager";
-import { Database, resolveCompoundName, UserData } from "../data/database";
-import { SessionData } from "../data/dataModels";
-import { ChatFatalError } from "../protocol/errors";
-import { ServerToClient } from "../protocol/messages";
-import { SessionRegistry } from "./sessionRegistry";
-
-const DEVELOPMENT: boolean = process.env.DEVELOPMENT === "1";
-
-dotenv.config();
-if (DEVELOPMENT) {
-  dotenv.config({ path: ".env.development" });
-}
-
-const logger = getLogger();
-
-/**
- * Extract error message from unknown error type
- */
-function extractErrorMessage(e: unknown): string {
-  if (typeof e === "string") return e;
-  if (e instanceof Error) return e.message;
-  return "Unknown connection error";
-}
-
-/**
- * Send error response and close WebSocket connection
- */
-function sendErrorAndClose(ws: ws.WebSocket, message: string): void {
-  try {
-    sendErrorResponse(ws, message);
-  } catch (closeError) {
-    logger.error(`[server] Error closing connection:`, closeError);
-  } finally {
-    ws.close(4000, message);
-  }
-}
-
-/**
- * Send error response but keep connection open
- */
-function sendErrorResponse(ws: ws.WebSocket, message: string): void {
-  try {
-    ws.send(
-      JSON.stringify({
-        t: "error",
-        e: message,
-      })
-    );
-  } catch (sendError) {
-    logger.error(`[server] Error sending error response:`, sendError);
-  }
-}
-
-export async function runServer(
-  port: number,
-  supabaseUrl: string,
-  supabaseKey: string,
-  xmcpUrl: string
-): Promise<ws.Server> {
-  return new Promise((r, _e) => {
-    const wss = new WebSocketServer({ port });
-    const db = new Database(supabaseUrl, supabaseKey);
-    const createSessionRegistry = (
-      connManager: IUserConnectionManager<ServerToClient>
-    ) => {
-      return new SessionRegistry(db, connManager, xmcpUrl);
-    };
-    const connectionManager = ConnectionManager.init(createSessionRegistry);
-
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    wss.on("connection", async (ws: ws.WebSocket, req: IncomingMessage) => {
-      try {
-        logger.info(`[server] connection: ${req.url || "unknown"}`);
-        logger.info(`[server] headers: ${JSON.stringify(req.headers)}`);
-
-        // Extract API key from WebSocket subprotocol header (formatted as
-        // comma-separated strings)
-        const subprotocols = req.headers["sec-websocket-protocol"];
-        if (!subprotocols) {
-          throw new ChatFatalError("empty api key");
-        }
-
-        if (typeof subprotocols !== "string") {
-          throw new ChatFatalError("subprotocols was not a string");
-        }
-        const protocols = subprotocols.split(",").map((p) => p.trim());
-        const apiKey = protocols[0];
-        if (!apiKey) {
-          throw new ChatFatalError("empty api key");
-        }
-
-        // Handle via ConnectionManager (multi-session protocol only)
-        await connectionManager.handleConnection(ws, apiKey, req);
-      } catch (e) {
-        logger.error(`[server] Connection error:`, e);
-
-        // Extract error message consistently
-        const errorMessage = extractErrorMessage(e);
-
-        if (e instanceof ChatFatalError) {
-          // Fatal errors: send error response and close connection
-          sendErrorAndClose(ws, errorMessage);
-        } else {
-          // Non-fatal errors: send error response but keep connection open
-          sendErrorResponse(ws, errorMessage);
-          logger.error(`[server] Client error:`, errorMessage);
-        }
-      }
-    });
-
-    logger.info(`[server] started: ws://localhost:${String(port)}/`);
-
-    r(wss);
-  });
-}
-
-export async function resolveSessionIdFromIdentifier(
-  db: Database,
-  sessionIdentifier: string
-): Promise<string | undefined> {
-  logger.info(`[resolveSessionIdFromIdentifier] ${sessionIdentifier}`);
-  let session: SessionData | undefined = undefined;
-  const compound = resolveCompoundName(sessionIdentifier);
-  logger.info(
-    `[resolveSessionIdFromIdentifier] compound: ${JSON.stringify(compound)}`
-  );
-  if (typeof compound === "string") {
-    // Interpret as an id
-    session = await db.sessionGetDescriptorById(compound);
-  } else {
-    session = await db.sessionGetDescriptorByName(compound[0], compound[1]);
-  }
-  logger.info(`[resolveSessionIdFromIdentifier] ${JSON.stringify(session)}`);
-  return session?.session_uuid;
-}
-
-/**
- * Try as id, then by user/name and return the AgentProfile uuid.
- */
-export async function resolveAgentProfileId(
-  db: Database,
-  userData: UserData,
-  agentProfileIdentifier: string
-): Promise<string | undefined> {
-  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;
-}
-
-// Export main classes for external use
-export { ConnectionManager } from "./connectionManager";
-export { OpenSession } from "./openSession";

package/src/chat/server/sessionFileManager.ts

@@ -1,422 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { strict as assert } from "assert";
-
-import {
-  AgentEx,
-  IAgentToolProvider,
-  ToolCallResult,
-  ToolHandler,
-} from "../../agent/agent";
-import { makeParseArgsFn } from "./tools";
-import { Database } from "../data/database";
-import { DbSessionFiles } from "../data/dbSessionFiles";
-import {
-  FileMetaData,
-  SessionFileDescriptor,
-  SessionFileEntry,
-  getSessionFileMimeTypeFromDataUrl,
-} from "../data/dbSessionFileModels";
-import { ToolDescriptor } from "../../agent/llm";
-
-/**
- * Tool call result with specific form of metadata
- */
-export type ToolCallResultWithFileRef = ToolCallResult<FileMetaData>;
-
-/**
- * Calling code implements this to be informed of file changes.
- */
-export interface ISessionFileManagerEventHandler {
-  onFileChanged(entry: SessionFileEntry, new_file: boolean): void;
-  onFileDeleted(name: string): void;
-}
-
-/**
- * Interface to a set of files in a session.
- */
-export interface ISessionFileManager {
-  /**
-   * List file names, types and summaries,
-   */
-  listFiles(): SessionFileDescriptor[];
-
-  /**
-   * Retrieve file contents.
-   */
-  getFileContent(name: string): Promise<string>;
-
-  /**
-   * Delete a file
-   */
-  deleteFile(name: string): Promise<void>;
-
-  /**
-   * Create or update a file with the given name.  Returns the name (which is
-   * created if one is not passed in).
-   */
-  putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): Promise<SessionFileDescriptor>;
-
-  addEventHandler(eventHandler: ISessionFileManagerEventHandler): void;
-}
-
-/**
- * In-memory implementation of ISessionFileManager
- */
-export class MemoryFileManager implements ISessionFileManager {
-  private readonly files: Map<string, SessionFileEntry>;
-  private eventHandlers: ISessionFileManagerEventHandler[];
-
-  constructor() {
-    this.files = new Map();
-    this.eventHandlers = [];
-  }
-
-  // ISessionFileManager.listFiles
-  listFiles(): SessionFileDescriptor[] {
-    return Array.from(this.files.values());
-  }
-
-  // ISessionFileManager.getFileContent
-  getFileContent(name: string): Promise<string> {
-    return new Promise((r, e) => {
-      const entry = this.files.get(name);
-      if (entry) {
-        r(entry.data_url);
-      } else {
-        e(new Error(`no such file ${name}`));
-      }
-    });
-  }
-
-  // ISessionFileManager.deleteFile
-  deleteFile(name: string): Promise<void> {
-    return new Promise((r, e) => {
-      if (this.files.has(name)) {
-        this.files.delete(name);
-        this.eventHandlers.forEach((eh) => {
-          eh.onFileDeleted(name);
-        });
-        r();
-      } else {
-        e(new Error(`no such file ${name}`));
-      }
-    });
-  }
-
-  // ISessionFileManager.addFile
-  putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): Promise<SessionFileDescriptor> {
-    return new Promise((r, e) => {
-      if (!name) {
-        name = uuidv4();
-      }
-      if (!summary) {
-        summary = "";
-      }
-      if (!isSingleLine(summary)) {
-        e(new Error("summary must no contain new-lines"));
-      } else {
-        const mime_type = getSessionFileMimeTypeFromDataUrl(data_url);
-        const is_new = !this.files.has(name);
-        const entry: SessionFileEntry = { name, mime_type, summary, data_url };
-        this.eventHandlers.forEach((eh) => {
-          eh.onFileChanged(entry, is_new);
-        });
-        this.files.set(name, entry);
-        r({ name, mime_type, summary });
-      }
-    });
-  }
-
-  // ISessionFileManager.setEventHandler
-  addEventHandler(eventHandler: ISessionFileManagerEventHandler) {
-    this.eventHandlers.push(eventHandler);
-  }
-}
-
-/**
- * Implementation of ISessionFileManager which can store files in the DB.
- */
-export class ChatSessionFileManager implements ISessionFileManager {
-  private readonly sessionUUID: string;
-  private readonly sfc: DbSessionFiles;
-  private readonly fileMap: Map<string, SessionFileDescriptor>;
-  private readonly fileDataCache: Map<string, string>;
-  private eventHandlers: ISessionFileManagerEventHandler[];
-
-  private constructor(
-    sfc: DbSessionFiles,
-    sessionUUID: string,
-    fileMap: Map<string, SessionFileDescriptor>
-  ) {
-    this.sessionUUID = sessionUUID;
-    this.sfc = sfc;
-    this.eventHandlers = [];
-    this.fileMap = fileMap;
-    this.fileDataCache = new Map();
-  }
-
-  static async init(
-    db: Database,
-    sessionUUID: string
-  ): Promise<ChatSessionFileManager> {
-    const sfc = db.createTypedClient(DbSessionFiles);
-    const fileList = await sfc.getFilesForSession(sessionUUID);
-    const fileMap = new Map(fileList.map((f) => [f.name, f]));
-    return new ChatSessionFileManager(sfc, sessionUUID, fileMap);
-  }
-
-  listFiles(): SessionFileDescriptor[] {
-    return Array.from(this.fileMap.values());
-  }
-
-  async getFileContent(name: string): Promise<string> {
-    const cached = this.fileDataCache.get(name);
-    if (cached) {
-      return cached;
-    }
-
-    if (!this.fileMap.has(name)) {
-      throw new Error(`no file '${name}' in session '${this.sessionUUID}'`);
-    }
-
-    const fileData = await this.sfc.getFileContent(this.sessionUUID, name);
-    if (!fileData) {
-      // logically should not happen
-      throw new Error(`empty file '${name}' in session '${this.sessionUUID}'`);
-    }
-
-    this.fileDataCache.set(name, fileData);
-    return fileData;
-  }
-
-  // ISessionFileManager.deleteFile
-  async deleteFile(name: string): Promise<void> {
-    if (this.fileMap.has(name)) {
-      this.fileMap.delete(name);
-      this.fileDataCache.delete(name);
-      await this.sfc.deleteFile(this.sessionUUID, name);
-      this.eventHandlers.forEach((eh) => {
-        eh.onFileDeleted(name);
-      });
-    } else {
-      throw new Error(`no file '${name}' in session '${this.sessionUUID}'`);
-    }
-  }
-
-  // ISessionFileManager.addFile
-  async putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): Promise<SessionFileDescriptor> {
-    if (!name) {
-      // TODO: have the LLM fill in the name?
-      name = uuidv4();
-    }
-    // TODO: have the LLM create summary if missing?
-
-    // If we have an existing entry in the cache then update it, otherwise
-    // create a new one.
-
-    const mime_type = getSessionFileMimeTypeFromDataUrl(data_url);
-    const existingDesc = this.fileMap.get(name);
-    if (existingDesc) {
-      existingDesc.summary = summary;
-      existingDesc.mime_type = mime_type;
-    } else {
-      this.fileMap.set(name, { name, summary, mime_type });
-    }
-
-    const is_new = !this.fileMap.has(name);
-    this.fileDataCache.set(name, data_url);
-    await this.sfc.setFileContent(this.sessionUUID, name, summary, data_url);
-    this.eventHandlers.forEach((eh) => {
-      assert(typeof name === "string");
-      eh.onFileChanged({ name, summary, mime_type, data_url }, is_new);
-    });
-    return { name, mime_type, summary };
-  }
-
-  // ISessionFileManager.setEventHandler
-  addEventHandler(eventHandler: ISessionFileManagerEventHandler) {
-    this.eventHandlers.push(eventHandler);
-  }
-
-  clearAllFiles(): Promise<void> {
-    this.fileMap.clear();
-    this.fileDataCache.clear();
-    return this.sfc.clearFiles(this.sessionUUID);
-  }
-
-  getSessionFileRelativeUrl(name: string): string {
-    return `file+session:/./${name}`;
-  }
-
-  getSessionFileAbsoluteUrl(name: string): string {
-    return `file+session://${this.sessionUUID}/${name}`;
-  }
-}
-
-/**
- * Return the file list in a form easily parsable by the LLM.
- */
-export function createSessionFilesManagerPrompt(
-  fm: ISessionFileManager
-): string {
-  const files = fm.listFiles();
-  if (files.length === 0) {
-    return "";
-  }
-  let prompt =
-    "Files can be read/written as required. Create new files conservatively, " +
-    "usually when complex content is requested. Use base64 for binary (image," +
-    "pdf), ascii for text formats (html,markdown). " +
-    "Available files:\nname,type,summary\n";
-  for (const f of files) {
-    prompt += `${f.name},${f.mime_type},${f.summary || ""}\n`;
-  }
-  return prompt;
-}
-
-const GET_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "get_file_content",
-    description: "Obtain contents of file listed in system prompt, as data-url",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-      },
-      required: ["name"],
-    },
-  },
-};
-
-const PUT_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "put_file_content",
-    description: "Create or update file content",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-        summary: {
-          type: "string",
-          description: "Content summary",
-        },
-        data_url: {
-          type: "string",
-          description:
-            "Content data-url: `data:<mime-type>[;<format>],<encoding>`",
-        },
-      },
-      required: ["name", "summary", "data_url"],
-    },
-  },
-};
-
-const DELETE_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "delete_file_content",
-    description: "Delete file",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-      },
-      required: ["name"],
-    },
-  },
-};
-
-export function fileManagerTool(
-  fileManager: ChatSessionFileManager
-): IAgentToolProvider {
-  // `get_file_content` tool
-  //
-  // LLM can read data from the file.  To keep the context small, we overwrite
-  // the data with the session file url after the LLM has seen it.
-
-  const parseName = makeParseArgsFn(["name"] as const);
-  const getFileContentFn: ToolHandler = async (
-    _agent: AgentEx,
-    args: unknown
-  ): Promise<ToolCallResult> => {
-    const { name } = parseName(args);
-    const response = await fileManager.getFileContent(name);
-    const overwriteResponse = fileManager.getSessionFileRelativeUrl(name);
-    return { response, overwriteResponse };
-  };
-
-  // `set_file_content` tool
-  //
-  // Allows LLM to write data (as a data-url) to the session file manager. The
-  // data is replaced by a session file url after being saved.
-
-  const putArgs = ["name", "summary", "data_url"] as const;
-  const parseNameSummaryDataUrl = makeParseArgsFn(putArgs);
-  const putFileContentFn: ToolHandler = async (
-    _: AgentEx,
-    args: unknown
-  ): Promise<ToolCallResultWithFileRef> => {
-    const parsed = parseNameSummaryDataUrl(args);
-    const { name, summary, data_url } = parsed;
-    const desc = await fileManager.putFileContent(name, summary, data_url);
-    const mimeType = getSessionFileMimeTypeFromDataUrl(data_url);
-    parsed.data_url = fileManager.getSessionFileRelativeUrl(name);
-    return {
-      response: desc.name,
-      overwriteArgs: JSON.stringify(parsed),
-      _meta: {
-        "xalia/fileUri": parsed.data_url,
-        "xalia/fileMimeType": mimeType,
-      },
-    };
-  };
-
-  // `delete_file_content` tool
-  //
-  // Allows LLM to write data (as a data-url) to the session file manager. The
-  // data is replaced by a session file url after being saved.
-
-  const deleteFileFn: ToolHandler = async (_: AgentEx, args: unknown) => {
-    const { name } = parseName(args);
-    await fileManager.deleteFile(name);
-    return { response: "" };
-  };
-
-  return {
-    setup: (agent: AgentEx) => {
-      agent.addAgentTool(GET_FILE_CONTENT_TOOL, getFileContentFn);
-      agent.addAgentTool(PUT_FILE_CONTENT_TOOL, putFileContentFn);
-      agent.addAgentTool(DELETE_FILE_CONTENT_TOOL, deleteFileFn);
-      return new Promise<void>((r) => {
-        r();
-      });
-    },
-  };
-}
-
-function isSingleLine(str: string): boolean {
-  return !/[\r\n]/.test(str);
-}