@xalia/agent 0.6.0 → 0.6.2

package/src/chat/client/sessionFiles.ts

@@ -0,0 +1,145 @@
+import { v4 as uuidv4 } from "uuid";
+import { strict as assert } from "assert";
+
+import { getLogger } from "@xalia/xmcp/sdk";
+import { SessionFileDescriptor } from "../data/dbSessionFileModels";
+import {
+  ClientToServer,
+  ServerSessionFileContent,
+  ServerSessionFileMessage,
+} from "../protocol/messages";
+import { ResponseHandler } from "./responseHandler";
+import { IMessageSender } from "./connection";
+
+const logger = getLogger();
+
+type ClientRequestContent = Extract<
+  ClientToServer,
+  { type: "session_file_get_content" }
+>;
+
+/// 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: ResponseHandler<
+    ClientRequestContent,
+    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 = new ResponseHandler(undefined);
+    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);
+    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;
+}

package/src/chat/data/apiKeyManager.ts

@@ -6,23 +6,71 @@ import { getLogger } from "@xalia/xmcp/sdk";
 
 const logger = getLogger();
 
+const API_KEY_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
 export class ApiKeyManager {
   constructor(private db: Database) {}
 
+  public static PREFIX = "xmcp";
+
   public async verifyApiKey(apiKey: string): Promise<UserData | undefined> {
     // TODO: Cache this
     logger.info(`[ApiKeyManager] Verifying API key: ${apiKey}`);
     const userInfo = await this.db.getUserDataFromApiKey(apiKey);
     logger.info(`[ApiKeyManager] User info: ${JSON.stringify(userInfo)}`);
     return userInfo;
+  }
+
+  /**
+   * Creates a standard api key of the form:
+   *
+   *   <prefix>_<[A-Z][a-z][0-9]+....>
+   *
+   * matching the format used in the mcppro backend
+   */
+  public static createApiKey(
+    prefix: string = ApiKeyManager.PREFIX,
+    length: number = 32
+  ): string {
+    // See mcppro/app/server/api_key.py:
+    //
+    //   def create_api_key(prefix: str, length: int = 32) -> str:
+    //       ...
+
+    const chars = Array.from({ length }, () => {
+      const i = Math.floor(Math.random() * API_KEY_ALPHABET.length);
+      return API_KEY_ALPHABET[i];
+    }).join("");
+    return `${prefix}_${chars}`;
+  }
+
+  /**
+   * Creates an api key of the form:
+   *
+   *   <prefix>_<[A-Z][a-z][0-9]+....>/<payload>
+   *
+   * where <payload> is used to convey extra data.
+   */
+  public static createApiKeyWithPayload(
+    prefix: string,
+    payload: string,
+    length: number = 32
+  ): string {
+    return `${ApiKeyManager.createApiKey(prefix, length)}_${payload}`;
+  }
 
-    // if (apiKey.startsWith("dummy_key")) {
-    //   return {
-    //     user_uuid: apiKey,
-    //     nickname: apiKey,
-    //   };
-    // }
+  /**
+   * Parse token (containing an api and optional payload)
+   */
+  public static parseToken(token: string): {
+    prefix: string;
+    apiKey: string;
+    payload: string | undefined;
+  } {
+    const [prefix, apiKeyVal, payload] = token.split("_");
+    const apiKey = `${prefix}_${apiKeyVal}`;
 
-    // return undefined;
+    return { prefix, apiKey, payload };
   }
 }

package/src/chat/data/dataModels.ts

@@ -1,5 +1,5 @@
 import { SavedAgentProfile } from "@xalia/xmcp/sdk";
-import { ChatCompletionMessageParam } from "../../agent/agent";
+import { ChatCompletionMessageParam } from "../../agent/llm";
 
 export type UserMessageData = {
   message?: string | undefined;
@@ -50,20 +50,29 @@ export type SessionCreateData = {
   title: string;
   agent_profile_uuid: string;
   user_uuid: string;
+
   team_uuid?: string | undefined;
-  workspace?: UserMessageData | undefined;
+  access_token?: string;
+  agent_paused: boolean;
 };
 
-/**
- * Data for existing session.
+/*
+ * Description of (unjoined) sessions.
  */
-export type SessionData = SessionCreateData & {
+export type SessionDescriptor = SessionCreateData & {
   updated_at: string;
 };
 
+/**
+ * Data for existing session, including any workspace data
+ */
+export type SessionData = SessionDescriptor & {
+  workspace?: UserMessageData | undefined;
+};
+
 export type AgentSessionData = {
   agent_profile: SavedAgentProfile;
-  sessions: SessionData[];
+  sessions: SessionDescriptor[];
   updated_at: number;
 };
 
@@ -75,7 +84,7 @@ export type TeamInfo = {
   team_name: string;
   owner_uuid: string;
   participants: Array<TeamParticipant>;
-  sessions: Array<SessionData>;
+  sessions: Array<SessionDescriptor>;
   agents: Array<SavedAgentProfile>;
 };
 

package/src/chat/data/database.ts

@@ -6,12 +6,12 @@ import {
   TeamParticipant,
   TeamRole,
   SessionParticipantMap,
-  SessionData,
   TeamInfo,
-  SessionMessage,
   SessionCheckpoint,
   UserMessageData,
   SessionCreateData,
+  SessionDescriptor,
+  SessionData,
 } from "./dataModels";
 import { createClient, SupabaseClient } from "@supabase/supabase-js";
 import type * as supabase from "../../../../supabase/database.types";
@@ -165,6 +165,16 @@ export class Database {
     }
   }
 
+  async deleteUser(user_uuid: string): Promise<void> {
+    const { error } = await this.client
+      .from("users")
+      .delete()
+      .eq("uuid", user_uuid);
+    if (error) {
+      throw error;
+    }
+  }
+
   async addApiKey(
     user_uuid: string,
     api_key: string,
@@ -337,6 +347,16 @@ export class Database {
     await this.client.from("agent_profiles").delete().neq("uuid", "");
   }
 
+  async deleteAgentProfile(agentProfileUuid: string): Promise<void> {
+    const { error } = await this.client
+      .from("agent_profiles")
+      .delete()
+      .eq("uuid", agentProfileUuid);
+    if (error) {
+      throw error;
+    }
+  }
+
   //
   // sessions
   //
@@ -384,13 +404,44 @@ export class Database {
     };
   }
 
-  async sessionGetByName(
+  async sessionGetDescriptorById(
+    session_uuid: string
+  ): Promise<SessionDescriptor | undefined> {
+    const { data, error } = await this.client
+      .from("sessions")
+      .select(
+        // eslint-disable-next-line max-len
+        "uuid,title,agent_profile_uuid,user_uuid,team_uuid,access_token,updated_at,agent_paused"
+      )
+      .eq("uuid", session_uuid)
+      .maybeSingle();
+
+    if (error) {
+      throw error;
+    }
+
+    if (!data) {
+      return undefined;
+    }
+
+    return {
+      ...data,
+      access_token: data.access_token || undefined,
+      session_uuid: data.uuid,
+      updated_at: data.updated_at || new Date().toISOString(),
+    };
+  }
+
+  async sessionGetDescriptorByName(
     user_uuid: string,
     session_name: string
-  ): Promise<SessionData | undefined> {
+  ): Promise<SessionDescriptor | undefined> {
     const { data, error } = await this.client
       .from("sessions")
-      .select("*")
+      .select(
+        // eslint-disable-next-line max-len
+        "uuid,title,agent_profile_uuid,user_uuid,team_uuid,access_token,updated_at,agent_paused"
+      )
       .eq("user_uuid", user_uuid)
       .eq("title", session_name)
       .maybeSingle();
@@ -399,11 +450,15 @@ export class Database {
       logger.error(`[getSessionByName] error: ${JSON.stringify(error)}`);
       throw error;
     }
+
+    if (!data) {
+      return undefined;
+    }
+
     return {
       ...data,
-      workspace: data.workspace || undefined,
-      owner_uuid: data.user_uuid,
       session_uuid: data.uuid,
+      access_token: data.access_token || undefined,
       updated_at: data.updated_at || new Date().toISOString(),
     };
   }
@@ -415,7 +470,7 @@ export class Database {
       agent_profile_uuid: session_data.agent_profile_uuid,
       user_uuid: session_data.user_uuid,
       team_uuid: session_data.team_uuid,
-      workspace: session_data.workspace,
+      access_token: session_data.access_token,
     };
     const { error } = await this.client.from("sessions").insert(payload);
     if (error) {
@@ -424,9 +479,7 @@ export class Database {
   }
 
   async sessionUpdateTitle(session_uuid: string, title: string): Promise<void> {
-    const payload: supabase.TablesUpdate<"sessions"> = {
-      title,
-    };
+    const payload: supabase.TablesUpdate<"sessions"> = { title };
     const { error } = await this.client
       .from("sessions")
       .update(payload)
@@ -452,6 +505,36 @@ export class Database {
     }
   }
 
+  async sessionUpdateAccessToken(
+    session_uuid: string,
+    access_token: string | undefined
+  ): Promise<void> {
+    const payload: supabase.TablesUpdate<"sessions"> = {
+      access_token: access_token || null,
+    };
+    const { error } = await this.client
+      .from("sessions")
+      .update(payload)
+      .eq("uuid", session_uuid);
+    if (error) {
+      throw error;
+    }
+  }
+
+  async sessionSetAgentPaused(
+    session_uuid: string,
+    paused: boolean
+  ): Promise<void> {
+    const payload: supabase.TablesUpdate<"sessions"> = { agent_paused: paused };
+    const { error } = await this.client
+      .from("sessions")
+      .update(payload)
+      .eq("uuid", session_uuid);
+    if (error) {
+      throw error;
+    }
+  }
+
   async sessionDeleteById(session_uuid: string): Promise<void> {
     await this.client.from("sessions").delete().eq("uuid", session_uuid);
   }
@@ -465,11 +548,12 @@ export class Database {
    * @param user_uuid
    * @returns SessionData[]
    */
-  async getUserSessions(user_uuid: string): Promise<SessionData[]> {
+  async getUserSessions(user_uuid: string): Promise<SessionDescriptor[]> {
     const { data: userSessions, error: userSessionsError } = await this.client
       .from("sessions")
       .select(
-        "uuid, title, agent_profile_uuid, workspace, updated_at, user_uuid"
+        // eslint-disable-next-line max-len
+        "uuid,title,agent_profile_uuid,updated_at,user_uuid,access_token,agent_paused"
       )
       .eq("user_uuid", user_uuid)
       .is("team_uuid", null);
@@ -483,9 +567,10 @@ export class Database {
       title: s.title,
       team_uuid: undefined,
       agent_profile_uuid: s.agent_profile_uuid,
-      workspace: s.workspace || undefined,
+      access_token: s.access_token || undefined,
       updated_at: s.updated_at,
       user_uuid: s.user_uuid,
+      agent_paused: s.agent_paused,
     }));
   }
 
@@ -522,90 +607,22 @@ export class Database {
   }
 
   async sessionGetTeamUuid(session_uuid: string): Promise<string | undefined> {
-    const data = await this.sessionGetById(session_uuid);
+    const data = await this.sessionGetDescriptorById(session_uuid);
     if (data) {
       return data.team_uuid;
     }
     return undefined;
   }
 
-  //
-  // session_messages
-  //
-
-  async sessionMessagesClearConversation(session_uuid: string): Promise<void> {
-    const { error } = await this.client
-      .from("session_messages")
-      .delete()
-      .eq("session_uuid", session_uuid);
-    if (error) {
-      throw error;
-    }
-  }
-
-  async sessionMessagesGetConversation(
-    session_uuid: string,
-    numEntries: number,
-    beforeIndex?: number
-  ): Promise<SessionMessage[]> {
-    // Query all message for the given session, ordered high-to-low by
-    // message_idx, limited to `numEntries`.  If `beforeIndex` is given, it
-    // means we get messages with `message_idx < beforeIndex`
-
-    let query = this.client
-      .from("session_messages")
-      .select("message_idx,sender_uuid,is_for_llm,content")
-      .eq("session_uuid", session_uuid);
-    if (beforeIndex) {
-      query = query.lt("message_idx", beforeIndex);
-    }
-    query = query.order("message_idx", { ascending: false }).limit(numEntries);
-
-    const { data, error } = await query;
-    if (error) {
-      throw error;
-    }
-
-    // To get the newest N messages, we've orded by index largest to smallest
-    // (newest first), but caller wants the message first to last, hence
-    // reverse the array.
-
-    return data
-      .map(({ sender_uuid, ...rest }) => {
-        return sender_uuid
-          ? {
-              sender_uuid,
-              ...rest,
-            }
-          : { ...rest };
-      })
-      .reverse();
-  }
-
-  async sessionMessagesAppend(
-    session_uuid: string,
-    messages: SessionMessage[]
-  ): Promise<void> {
-    const payload = messages.map((m) => {
-      return { ...m, session_uuid };
-    });
-    const { error } = await this.client
-      .from("session_messages")
-      .insert(payload);
-    if (error) {
-      throw error;
-    }
-  }
-
   //
   // session_checkpoints
   //
 
-  async sessionCheckpointsClear(): Promise<void> {
+  async sessionCheckpointDelete(session_uuid: string): Promise<void> {
     const { error } = await this.client
       .from("session_checkpoints")
       .delete()
-      .neq("session_uuid", "");
+      .neq("session_uuid", session_uuid);
     if (error) {
       throw error;
     }
@@ -681,7 +698,7 @@ export class Database {
    * @param teamUuid - UUID of the team
    * @returns Array of agent profiles
    */
-  async AgentProfilesGetByTeam(teamUuid: string): Promise<SavedAgentProfile[]> {
+  async agentProfilesGetByTeam(teamUuid: string): Promise<SavedAgentProfile[]> {
     const { data, error } = await this.client
       .from("agent_profiles")
       .select("*")
@@ -859,7 +876,7 @@ export class Database {
       const [participants, sessions, agents] = await Promise.all([
         this.teamGetMembers(teamUuid),
         this.teamGetSessions(teamUuid),
-        this.AgentProfilesGetByTeam(teamUuid),
+        this.agentProfilesGetByTeam(teamUuid),
       ]);
 
       return {
@@ -951,12 +968,10 @@ export class Database {
    * @param teamUuid - UUID of the team
    * @returns Array of session data
    */
-  async teamGetSessions(teamUuid: string): Promise<SessionData[]> {
+  async teamGetSessions(teamUuid: string): Promise<SessionDescriptor[]> {
     const { data, error } = await this.client
       .from("sessions")
-      .select(
-        "uuid, title, agent_profile_uuid, workspace, updated_at, user_uuid"
-      )
+      .select("uuid,title,agent_profile_uuid,updated_at,user_uuid,agent_paused")
       .eq("team_uuid", teamUuid);
 
     if (error) {
@@ -968,9 +983,9 @@ export class Database {
       title: session.title,
       team_uuid: teamUuid,
       agent_profile_uuid: session.agent_profile_uuid,
-      workspace: session.workspace || undefined,
       updated_at: session.updated_at || new Date().toISOString(),
       user_uuid: session.user_uuid,
+      agent_paused: session.agent_paused,
     }));
   }
 

package/src/chat/data/dbSessionFileModels.ts

@@ -0,0 +1,91 @@
+import {
+  IMAGE_MIME_TYPES,
+  EXTENSION_TO_IMAGE_MIME_TYPE,
+  getMimeTypeFromDataUrl,
+  createDataUrlFromText,
+  createDataUrlFromBuffer,
+} from "./mimeTypes";
+
+export const SESSION_FILE_MIME_TYPES = [
+  ...IMAGE_MIME_TYPES,
+  "text/plain",
+  "text/markdown",
+  "application/pdf",
+  "image/svg+xml",
+] as const;
+
+export type SessionFileMimeType = (typeof SESSION_FILE_MIME_TYPES)[number];
+
+export function isSessionFileMimeType(
+  mime_type: unknown
+): mime_type is SessionFileMimeType {
+  return (
+    typeof mime_type === "string" &&
+    (SESSION_FILE_MIME_TYPES as readonly string[]).includes(mime_type)
+  );
+}
+
+export const SESSION_FILE_TEXT_MIME_TYPES = [
+  "text/plain",
+  "text/markdown",
+] as const;
+
+export type SessionFileTextMimeType =
+  (typeof SESSION_FILE_TEXT_MIME_TYPES)[number];
+
+export function isSessionFileTextMimeType(
+  mime_type: unknown
+): mime_type is SessionFileTextMimeType {
+  return (
+    typeof mime_type === "string" &&
+    (SESSION_FILE_TEXT_MIME_TYPES as readonly string[]).includes(mime_type)
+  );
+}
+
+export const EXTENSION_TO_SESSION_FILE_MIME_TYPE: Record<
+  string,
+  SessionFileMimeType | undefined
+> = {
+  ...EXTENSION_TO_IMAGE_MIME_TYPE,
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+};
+
+export type SessionFileDescriptor = {
+  name: string;
+  mime_type: SessionFileMimeType;
+  summary?: string;
+};
+
+export type SessionFileEntry = SessionFileDescriptor & { data_url: string };
+
+export function getSessionFileMimeTypeFromDataUrl(
+  data_url: string
+): SessionFileMimeType {
+  const mimeType = getMimeTypeFromDataUrl(data_url);
+  if (!isSessionFileMimeType(mimeType)) {
+    throw new Error(`${mimeType} is not a supported mime type`);
+  }
+  return mimeType;
+}
+
+export function createSessionFileDataUrl(
+  data: string,
+  mime_type: SessionFileTextMimeType
+): string;
+export function createSessionFileDataUrl(
+  data: Buffer,
+  mime_type: SessionFileMimeType
+): string;
+export function createSessionFileDataUrl(
+  data: string | Buffer,
+  mime_type: SessionFileMimeType | SessionFileTextMimeType
+): string {
+  if (typeof data === "string") {
+    return createDataUrlFromText(data, mime_type);
+  } else {
+    return createDataUrlFromBuffer(data, mime_type);
+  }
+}