@xalia/agent 0.5.0 → 0.5.1

package/src/chat/db.ts

@@ -0,0 +1,264 @@
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
+import type * as supabase from "../../../supabase/database.types";
+import {
+  AgentProfile,
+  ApiKey,
+  getLogger,
+  SavedAgentProfile,
+} from "@xalia/xmcp/sdk";
+
+const logger = getLogger();
+
+export const SUPABASE_LOCAL_URL = "http://127.0.0.1:54321";
+export const SUPABASE_LOCAL_KEY =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiw" +
+  "icm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJz" +
+  "dJsyH-qQwv8Hdp7fsn3W0YpN81IU";
+
+/**
+ * 'name' -> 'name'
+ * 'space/name' -> ['space', 'name']
+ */
+export function resolveCompoundName(name: string): string | [string, string] {
+  const components = name.split("/");
+  if (components.length === 1) {
+    return name;
+  }
+  if (components.length !== 2) {
+    throw "invalid compound name";
+  }
+  return components as [string, string];
+}
+
+export type UserData = {
+  user_uuid: supabase.Tables<"api_keys">["user_uuid"];
+  nickname: supabase.Tables<"users">["nickname"];
+};
+
+export class Database {
+  private client: SupabaseClient<Database>;
+
+  constructor(supabaseUrl: string, supabaseKey: string) {
+    this.client = createClient<Database>(supabaseUrl, supabaseKey);
+  }
+
+  async getUserDataFromApiKey(apiKey: string): Promise<UserData | undefined> {
+    const { data, error } = await this.client
+      .from("api_keys")
+      .select("user_uuid, users ( nickname )")
+      .eq("api_key", apiKey)
+      .maybeSingle<{
+        user_uuid: supabase.Tables<"api_keys">["user_uuid"];
+        users: {
+          nickname: supabase.Tables<"users">["nickname"];
+        };
+      }>();
+
+    logger.debug(
+      `[getUserDataFromApiKey]: got ${JSON.stringify({ data, error })}`
+    );
+
+    if (error) {
+      throw error;
+    }
+
+    if (data === null) {
+      return undefined;
+    }
+
+    return {
+      user_uuid: data.user_uuid,
+      nickname: data.users.nickname || `user ${data.user_uuid}`,
+    };
+  }
+
+  async createUser(
+    user_uuid: string,
+    email: string,
+    nickname: string,
+    timezone?: string
+  ): Promise<void> {
+    const payload: supabase.TablesInsert<"users"> = {
+      uuid: user_uuid,
+      email,
+      nickname,
+      timezone: timezone || "UTC",
+    };
+
+    const { error } = await this.client.from("users").insert(payload);
+    if (error) {
+      throw error;
+    }
+  }
+
+  async addApiKey(
+    user_uuid: string,
+    api_key: string,
+    name: string,
+    scopes: string[],
+    is_default: boolean = false
+  ): Promise<ApiKey> {
+    const payload: supabase.TablesInsert<"api_keys"> = {
+      user_uuid,
+      api_key,
+      name,
+      scopes,
+      is_default,
+    };
+    const { data, error } = await this.client
+      .from("api_keys")
+      .insert(payload)
+      .select("*")
+      .maybeSingle();
+    if (error) {
+      throw error;
+    }
+
+    return data;
+  }
+
+  async getSavedAgentProfileById(
+    agentProfileId: string
+  ): Promise<SavedAgentProfile | undefined> {
+    const { data, error } = await this.client
+      .from("agent_profiles")
+      .select("*")
+      .eq("uuid", agentProfileId)
+      .maybeSingle<supabase.Tables<"agent_profiles">>();
+    if (error) {
+      throw error;
+    }
+
+    return data
+      ? SavedAgentProfile.fromJSONObj(data as Record<string, unknown>)
+      : undefined;
+  }
+
+  async getSavedAgentProfileByName(
+    user_uuid: string,
+    agentProfileName: string
+  ): Promise<SavedAgentProfile | undefined> {
+    const { data, error } = await this.client
+      .from("agent_profiles")
+      .select("*")
+      .eq("user_uuid", user_uuid)
+      .eq("profile_name", agentProfileName)
+      .maybeSingle<supabase.Tables<"agent_profiles">>();
+    if (error) {
+      throw error;
+    }
+
+    return data
+      ? SavedAgentProfile.fromJSONObj(data as Record<string, unknown>)
+      : undefined;
+  }
+
+  async getAgentProfileById(
+    agentProfileId: string
+  ): Promise<AgentProfile | undefined> {
+    const { data, error } = await this.client
+      .from("agent_profiles")
+      .select("profile")
+      .eq("uuid", agentProfileId)
+      .maybeSingle<{
+        profile: supabase.Tables<"agent_profiles">["profile"];
+      }>();
+    if (error) {
+      throw error;
+    }
+    return data
+      ? AgentProfile.fromJSONObj(data.profile as Record<string, unknown>)
+      : undefined;
+  }
+
+  async createAgentProfile(
+    user_uuid: string,
+    profileName: string,
+    profile: AgentProfile
+  ): Promise<string | undefined> {
+    const payload: supabase.TablesInsert<"agent_profiles"> = {
+      profile: profile as unknown as supabase.Json,
+      user_uuid,
+      profile_name: profileName,
+    };
+    const { data, error } = await this.client
+      .from("agent_profiles")
+      .upsert(payload)
+      .select("uuid");
+    if (error) {
+      throw error;
+    }
+
+    if (!data || !data[0] || !data[0].uuid) {
+      return undefined;
+    }
+
+    return data[0].uuid;
+  }
+
+  async clearAgentProfiles(): Promise<void> {
+    await this.client.from("agent_profiles").delete().neq("uuid", "");
+  }
+
+  // TODO: is there a session model?
+
+  async getSessionById(
+    session_uuid: string
+  ): Promise<supabase.Tables<"sessions"> | undefined> {
+    const { data, error } = await this.client
+      .from("sessions")
+      .select("*")
+      .eq("uuid", session_uuid)
+      .maybeSingle();
+    if (error) {
+      throw error;
+    }
+    return data;
+  }
+
+  async getSessionByName(
+    user_uuid: string,
+    session_name: string
+  ): Promise<supabase.Tables<"sessions"> | undefined> {
+    const { data, error } = await this.client
+      .from("sessions")
+      .select("*")
+      .eq("user_uuid", user_uuid)
+      .eq("title", session_name)
+      .maybeSingle();
+    if (error) {
+      throw error;
+    }
+    return data;
+  }
+
+  async createSession(
+    user_uuid: string,
+    title: string,
+    agentProfileId: string
+  ): Promise<string | undefined> {
+    const payload: supabase.TablesInsert<"sessions"> = {
+      agent_profile_uuid: agentProfileId,
+      user_uuid,
+      title: title,
+      conversation: [],
+    };
+    const { data, error } = await this.client
+      .from("sessions")
+      .upsert(payload)
+      .select("uuid");
+    if (error) {
+      throw error;
+    }
+
+    if (!data || !data[0] || !data[0].uuid) {
+      return undefined;
+    }
+
+    return data[0].uuid;
+  }
+
+  async clearSessions(): Promise<void> {
+    await this.client.from("sessions").delete().neq("uuid", "");
+  }
+}

package/src/chat/messages.ts

@@ -0,0 +1,91 @@
+import {
+  ChatCompletionMessageParam,
+  ChatCompletionAssistantMessageParam,
+  ChatCompletionToolMessageParam,
+  ChatCompletionMessageToolCall,
+} from "openai/resources.mjs";
+
+/**
+ * Message from a user to the server
+ */
+export type ClientUserMessage = {
+  type: "msg";
+  message: string;
+};
+
+/**
+ * (from server) Chat history
+ */
+export type ServerHistory = {
+  type: "history";
+  /// Conversation history in the form we expect.  The `name` attribute of
+  /// `ChatCompletionUserMessageParam` (role: "user") holds the original
+  /// message sender.
+  messages: ChatCompletionMessageParam[];
+};
+
+export type ServerUserJoined = {
+  type: "user_joined";
+  user: string;
+};
+
+export type ServerUserLeft = {
+  type: "user_left";
+  user: string;
+};
+
+/**
+ * Message from the server, informing us of a message in the chat history
+ */
+export type ServerUserMessage = {
+  type: "user_msg";
+  message_id: string;
+  message: string;
+  from: string;
+};
+
+export type ServerAgentMessage = {
+  type: "agent_msg";
+  message_id: string;
+  message: ChatCompletionAssistantMessageParam;
+};
+
+export type ServerAgentMessageChunk = {
+  type: "agent_msg_chunk";
+  message_id: string;
+  message: string;
+  end: boolean;
+};
+
+/**
+ * For information only (to keep the chat window consistent).
+ */
+export type ServerToolCall = {
+  type: "agent_tool_call";
+  message_id: string;
+  message: ChatCompletionMessageToolCall;
+};
+
+/**
+ * For information only (to keep the chat window consistent)
+ */
+export type ServerToolCallResult = {
+  type: "tool_call_result";
+  message_id: string;
+  message: ChatCompletionToolMessageParam;
+};
+
+export type ServerTyping = {
+  type: "typing";
+  from: string;
+};
+
+export type ClientToServer = ClientUserMessage;
+
+export type ServerToClient =
+  | ServerUserJoined
+  | ServerUserLeft
+  | ServerUserMessage
+  | ServerAgentMessage
+  | ServerAgentMessageChunk
+  | ServerTyping;

package/src/chat/server.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+// -*- typescript -*-
+
+import type * as supabase from "../../../supabase/database.types";
+import * as dotenv from "dotenv";
+import { getLogger } from "@xalia/xmcp/sdk";
+import * as ws from "ws";
+import { IncomingMessage } from "http";
+import { parse } from "url";
+import { ConversationManager } from "./conversationManager";
+import { Database, UserData, resolveCompoundName } from "./db";
+import { ApiKeyManager } from "./apiKeyManager";
+import { ParsedUrlQuery } from "querystring";
+
+dotenv.config();
+
+const logger = getLogger();
+
+/**
+ * Try as id, then by user/name and return the AgentProfile uuid.
+ */
+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.user_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: Database,
+  userData: UserData,
+  sessionIdentifier: string
+): Promise<string | undefined> {
+  let session: supabase.Tables<"sessions"> | undefined = undefined;
+  const compound = 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.user_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: Database,
+  userData: UserData,
+  query: ParsedUrlQuery
+): Promise<string | undefined> {
+  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.user_uuid, query.session_id, agentProfileId);
+}
+
+export async function runServer(
+  port: number,
+  supabaseUrl: string,
+  supabaseKey: string,
+  llmUrl: string,
+  xmcpUrl: string
+): Promise<ws.Server> {
+  return new Promise((r, _e) => {
+    const wss = new ws.Server({ port });
+    const db = new Database(supabaseUrl, supabaseKey);
+    const apiKeyManager = new ApiKeyManager(db);
+    const cm = new ConversationManager(db, llmUrl, xmcpUrl);
+
+    wss.on("connection", async (ws: ws.WebSocket, req: IncomingMessage) => {
+      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 } = 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/test/db.test.ts

@@ -0,0 +1,103 @@
+import { expect } from "chai";
+import { Database, SUPABASE_LOCAL_KEY, SUPABASE_LOCAL_URL } from "../chat/db";
+import { AgentProfile } from "../agent/agent";
+import { strict as assert } from "assert";
+import { ApiClient } from "@xalia/xmcp/sdk";
+import { LOCAL_SERVER_URL } from "../agent/sudoMcpServerManager";
+
+function getLocalDB(): Database {
+  return new Database(SUPABASE_LOCAL_URL, SUPABASE_LOCAL_KEY);
+}
+
+const AGENT_PROFILE: AgentProfile = {
+  model: undefined,
+  system_prompt: "You are an unhelpful agent",
+  mcp_settings: {},
+};
+
+async function createDummyUser(db: Database): Promise<void> {
+  const apiClient = new ApiClient(LOCAL_SERVER_URL, "dummy_key");
+  const user = await apiClient.getUserBrief("dummy_user");
+  if (!user) {
+    await db.createUser("dummy_user", "a@b.com", "Dummy User");
+    await db.addApiKey("dummy_user", "dummy_key", "default", [], true);
+    if (!apiClient.getUserBrief("dummy_user")) {
+      throw "unable to create dummy user";
+    }
+  }
+}
+
+describe("DB", () => {
+  it("should get existing user", async function () {
+    const db = getLocalDB();
+    await createDummyUser(db);
+    const dummyUser = await db.getUserDataFromApiKey("dummy_key");
+    expect(dummyUser).eql({
+      user_uuid: "dummy_user",
+      nickname: "Dummy User",
+    });
+  });
+
+  it("should return undefined for non-existant user", async function () {
+    const db = getLocalDB();
+    const dummyUser = await db.getUserDataFromApiKey("no_such_key");
+    expect(dummyUser).to.equal(undefined);
+  });
+
+  it("should create and retrieve agent profiles", async function () {
+    const db = getLocalDB();
+
+    await db.clearAgentProfiles();
+    const agentProfileId = await db.createAgentProfile(
+      "dummy_user",
+      "test_profile",
+      AGENT_PROFILE
+    );
+    expect(agentProfileId).to.not.equal(undefined);
+    assert(agentProfileId);
+
+    const savedAgentProfile =
+      (await db.getSavedAgentProfileById(agentProfileId))!;
+    const savedAgentProfileByName = (await db.getSavedAgentProfileByName(
+      "dummy_user",
+      "test_profile"
+    ))!;
+    const agentProfile = (await db.getAgentProfileById(agentProfileId))!;
+
+    expect(savedAgentProfile.uuid).eql(agentProfileId);
+    expect(savedAgentProfile.profile).eql(AGENT_PROFILE);
+    expect(savedAgentProfile?.user_uuid).eql("dummy_user");
+    expect(savedAgentProfile?.profile_name).eql("test_profile");
+
+    expect(savedAgentProfileByName).eql(savedAgentProfile);
+
+    expect(agentProfile).eql(AGENT_PROFILE);
+  });
+
+  it("should create and retrieve sessions", async function () {
+    const db = getLocalDB();
+
+    await db.clearAgentProfiles();
+    await db.clearSessions();
+    const agentProfileId = await db.createAgentProfile(
+      "dummy_user",
+      "test_profile",
+      AGENT_PROFILE
+    );
+    assert(agentProfileId);
+
+    const sessionId = await db.createSession(
+      "dummy_user",
+      "test_session",
+      agentProfileId
+    );
+    assert(sessionId);
+    const session = (await db.getSessionById(sessionId))!;
+
+    expect(session.agent_profile_uuid).eql(agentProfileId);
+    expect(session.conversation).eql([]);
+    expect(session.title).eql("test_session");
+    expect(session.user_uuid).eql("dummy_user");
+    expect(session.uuid).eql(sessionId);
+  });
+});

package/src/test/imageLoad.test.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { loadImageB64OrUndefined } from "../files";
+import { loadImageB64OrUndefined } from "../tool/files";
 import { strict as assert } from "assert";
 
 describe("Image loading", () => {

package/src/test/mcpServerManager.test.ts

@@ -3,7 +3,7 @@ import {
   computeQualifiedName,
   McpServerManager,
   splitQualifiedName,
-} from "../mcpServerManager";
+} from "../agent/mcpServerManager";
 
 // Handle automatically closing at the end of tests.
 

package/src/test/prompt.test.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { parsePrompt } from "../prompt";
+import { parsePrompt } from "../tool/prompt";
 
 describe("Prompt", () => {
   it("should recognise commands", async function () {

package/src/test/sudoMcpServerManager.test.ts

@@ -1,20 +1,16 @@
 import { expect } from "chai";
-import { McpServerManager } from "../mcpServerManager";
-import {
-  SudoMcpServerManager,
-  LOCAL_SERVER_URL,
-} from "../sudoMcpServerManager";
 import chalk from "chalk";
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
 
-let managers: [McpServerManager, SudoMcpServerManager] | undefined = undefined;
+import { McpServerManager } from "../agent/mcpServerManager";
+import { SkillManager, LOCAL_SERVER_URL } from "../agent/sudoMcpServerManager";
 
-async function getServerManagers(): Promise<
-  [McpServerManager, SudoMcpServerManager]
-> {
+let managers: [McpServerManager, SkillManager] | undefined = undefined;
+
+async function getServerManagers(): Promise<[McpServerManager, SkillManager]> {
   if (!managers) {
     const tm = new McpServerManager();
-    const sm = await SudoMcpServerManager.initialize(
+    const sm = await SkillManager.initialize(
       tm,
       (_url: string) => {
         throw "unexpected call to openUrl";