@xalia/agent 0.6.0 → 0.6.2

package/dist/agent/src/agent/openAILLMStreaming.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAILLMStreaming = void 0;
 exports.initializeCompletion = initializeCompletion;
 exports.updateCompletion = updateCompletion;
-const sdk_1 = require("@xalia/xmcp/sdk");
 const openai_1 = require("openai");
 const assert_1 = require("assert");
-const agentUtils_1 = require("./agentUtils");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const llm_1 = require("./llm");
 const logger = (0, sdk_1.getLogger)();
 function initialToolCallFunction(deltaFn) {
     //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
@@ -152,6 +152,14 @@ function initializeCompletionMessage(delta) {
         tool_calls: toolCalls,
     };
 }
+function updateReasoning(message, reasoning) {
+    if (!message.reasoning) {
+        message.reasoning = reasoning;
+    }
+    else {
+        message.reasoning += reasoning;
+    }
+}
 function updateCompletionMessage(message, delta) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     (0, assert_1.strict)(message.role === "assistant");
@@ -160,12 +168,20 @@ function updateCompletionMessage(message, delta) {
     (0, assert_1.strict)(!message.audio);
     (0, assert_1.strict)(message.tool_calls instanceof Array ||
         typeof message.tool_calls === "undefined");
-    //   export interface ChatCompletionChunk.Choice.Delta {
+    //   export interface ChatCompletionChunkChoiceDeltaWithReasoning {
     //     content?: string | null;
     //     function_call?: Delta.FunctionCall;
     //     refusal?: string | null;
     //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
     //     tool_calls?: Array<Delta.ToolCall>;
+    //
+    //     reasoning?: string;
+    //     reasoning_details?: {
+    //       type: "reasoning.text",
+    //       text?: string,
+    //       format?: string,
+    //       index?:0
+    //     }[]
     //   }
     //
     // ->
@@ -178,6 +194,8 @@ function updateCompletionMessage(message, delta) {
     //     audio?: ChatCompletionAudio | null;
     //     function_call?: ChatCompletionMessage.FunctionCall | null;
     //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //
+    //     reasoning?: string;
     //   }
     if (delta.content) {
         if (message.content) {
@@ -203,6 +221,10 @@ function updateCompletionMessage(message, delta) {
             message.tool_calls = updateToolCalls(message.tool_calls, t);
         }
     }
+    const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+    if (reasoning) {
+        updateReasoning(message, reasoning);
+    }
 }
 function initializeCompletionChoice(chunkChoice) {
     //   export interface ChatCompletionChunk.Choice {
@@ -377,9 +399,9 @@ class OpenAILLMStreaming {
             apiKey,
             baseURL: apiUrl,
             dangerouslyAllowBrowser: true,
-            defaultHeaders: agentUtils_1.XALIA_APP_HEADER,
+            defaultHeaders: llm_1.XALIA_APP_HEADER,
         });
-        this.model = model || agentUtils_1.DEFAULT_LLM_MODEL;
+        this.model = model;
     }
     setModel(model) {
         this.model = model;
@@ -390,7 +412,11 @@ class OpenAILLMStreaming {
     getUrl() {
         return this.openai.baseURL;
     }
-    async getConversationResponse(messages, tools, onMessage) {
+    async getConversationResponse(messages, tools, onMessage, onReasoning) {
+        const reasoning = {
+            effort: "medium",
+            enabled: true,
+        };
         const chunks = await this.openai.chat.completions.create({
             model: this.model,
             messages,
@@ -399,6 +425,7 @@ class OpenAILLMStreaming {
             stream_options: {
                 include_usage: true,
             },
+            extra_body: { reasoning },
         });
         // Check the type casting above
         if (!chunks.iterator) {
@@ -430,6 +457,14 @@ class OpenAILLMStreaming {
                     await onMessage(delta.content, false);
                 }
             }
+            if (onReasoning) {
+                const delta = chunk.choices[0]
+                    ?.delta;
+                const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+                if (reasoning) {
+                    await onReasoning(reasoning);
+                }
+            }
         }
         if (onMessage) {
             await onMessage("", true);

package/dist/agent/src/chat/client/chatClient.js

@@ -15,7 +15,9 @@ class ChatClient {
     // agent_uuid -> agent session data
     userAgentSessionMap = new Map(), 
     // team_uuid -> team info
-    teams = new Map(), closed = false, currentSessionId = undefined, 
+    teams = new Map(), 
+    // Whether this client is in guest mode
+    isGuestMode = false, closed = false, currentSessionId = undefined, 
     // note: currentTeamId will not be reset when swtiching to a user session.
     currentTeamId = undefined, 
     // session_uuid -> session client
@@ -28,6 +30,7 @@ class ChatClient {
         this.eventHandler = eventHandler;
         this.userAgentSessionMap = userAgentSessionMap;
         this.teams = teams;
+        this.isGuestMode = isGuestMode;
         this.closed = closed;
         this.currentSessionId = currentSessionId;
         this.currentTeamId = currentTeamId;
@@ -39,6 +42,8 @@ class ChatClient {
      * Connect to server and create ChatClient instance
      */
     static async init(url, token, eventHandler) {
+        // Determine if this is a guest token (format: guest_<hash>_<session-id>)
+        const isGuestMode = token.startsWith('guest_');
         const connection = new connection_1.Connection({
             url,
             token,
@@ -69,7 +74,7 @@ class ChatClient {
                 });
                 if (!client) {
                     logger.info("Creating ChatClient");
-                    client = new ChatClient(connection, eventHandler, userAgentSessionMap, teams);
+                    client = new ChatClient(connection, eventHandler, userAgentSessionMap, teams, isGuestMode);
                     resolveClient(client);
                 }
                 else {
@@ -364,6 +369,22 @@ class ChatClient {
         });
         logger.debug(`[ChatClient] Sent session_delete_request for` + ` session ${sessionId}`);
     }
+    /**
+     * Delete an agent profile by sending control_agent_profile_delete message
+     * @param agentProfileUuid - The UUID of the agent profile to delete
+     * @returns void
+     */
+    deleteAgentProfile(agentProfileUuid) {
+        if (this.closed) {
+            throw new Error("ChatClient is closed");
+        }
+        this.connection.send({
+            type: "control_agent_profile_delete",
+            agent_profile_uuid: agentProfileUuid,
+        });
+        logger.debug(`[ChatClient] Sent control_agent_profile_delete for profile ` +
+            agentProfileUuid);
+    }
     /**
      * Create a new team with initial members
      * @param teamName
@@ -513,6 +534,9 @@ class ChatClient {
             case "control_team_created":
                 this.handleTeamCreatedMessage(msg);
                 break;
+            case "control_team_members_updated":
+                this.handleTeamMembersUpdated(msg);
+                break;
             default: {
                 const _exhaustive = msg;
                 throw new Error(`unexpected control msg: ${JSON.stringify(msg)}`);
@@ -541,8 +565,29 @@ class ChatClient {
         }
         void this.eventHandler.onMessage(msg, this);
     }
-    handleAgentProfileDeleted(_msg) {
-        throw new Error("handleAgentProfileDeleted not implemented");
+    handleAgentProfileDeleted(msg) {
+        logger.debug(`[ChatClient.handleAgentProfileDeleted] msg: ${JSON.stringify(msg)}`);
+        const profileUuid = msg.profile_uuid;
+        let found = false;
+        // Try to remove from user agent session map
+        if (this.userAgentSessionMap.has(profileUuid)) {
+            this.userAgentSessionMap.delete(profileUuid);
+            found = true;
+        }
+        else {
+            // Try to remove from team agent session maps
+            for (const [_teamId, team] of this.teams.entries()) {
+                if (team.agentSessionMap.has(profileUuid)) {
+                    team.agentSessionMap.delete(profileUuid);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            logger.warn(`[ChatClient] Agent profile ${profileUuid} not found in any session map`);
+        }
+        void this.eventHandler.onMessage(msg, this);
     }
     handleSessionMessage(msg) {
         const sessionId = msg.session_id;
@@ -587,6 +632,19 @@ class ChatClient {
         void this.eventHandler.onMessage(msg, this);
         return;
     }
+    handleTeamMembersUpdated(msg) {
+        const team = this.teams.get(msg.team_uuid);
+        if (!team) {
+            logger.warn(`[ChatClient] Received team_members_updated for unknown team ` +
+                msg.team_uuid);
+            return;
+        }
+        // Update the participants map
+        team.participants = new Map(msg.members.map((participant) => [participant.user_uuid, participant]));
+        logger.info(`[ChatClient] Updated team members for team ${msg.team_uuid}, ` +
+            `now has ${String(msg.members.length)} members`);
+        void this.eventHandler.onMessage(msg, this);
+    }
     /**
      * Handle session_info message which can be for:
      * 1. A pending session join/create request
@@ -602,7 +660,7 @@ class ChatClient {
             try {
                 logger.info(`[ChatClient] Creating SessionClient for session ${sessionId}`);
                 logger.info(`[ChatClient] msg: ${JSON.stringify(msg)}`);
-                const sessionClient = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants));
+                const sessionClient = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants), msg.agent_paused);
                 // we need to pass the session id if this is a new session
                 if (this.sessionJoinOrCreateRes.sessionId === "") {
                     this.sessionJoinOrCreateRes.sessionId = sessionId;
@@ -639,12 +697,18 @@ class ChatClient {
      */
     updateAgentSessionMap(sessionInfo) {
         const sessionId = sessionInfo.session_id;
+        // Skip agent session map updates for guest sessions since they don't
+        // need session organization
+        if (this.isGuestMode) {
+            logger.info(`[ChatClient] Skipping agent session map update for ` +
+                `guest session ${sessionId}`);
+            return;
+        }
         if (sessionInfo.team_uuid) {
             const teamInfo = this.teams.get(sessionInfo.team_uuid);
             if (!teamInfo) {
                 throw new Error(`Team ${sessionInfo.team_uuid} not found in team list`);
             }
-            //teamInfo.sessions.set(sessionId, ChatClient.toSessionData(sessionInfo));
             const agentSessionMap = teamInfo.agentSessionMap;
             if (!doUpdateAgentSessionMap(agentSessionMap, sessionInfo)) {
                 throw new Error(`[updateAgentSessionMap] team session ${sessionId}` +
@@ -660,9 +724,9 @@ class ChatClient {
         }
     }
     /**
-     * Update the session info for an existing session. This passes the session
-     * info to the session client. An error is thrown if the session client is not
-     * found.
+     * Update the SessionDescriptor info for an existing session, given a full
+     * ServerSessionInfo. This also passes the session info to the session
+     * client. An error is thrown if the session client is not found.
      */
     updateSessionInfo(msg) {
         const sessionId = msg.session_id;
@@ -676,6 +740,13 @@ class ChatClient {
         }
     }
     addSessionToAgentSessionMap(msg) {
+        // Skip agent session map updates for guest sessions since they don't
+        // need session organization
+        if (this.isGuestMode) {
+            logger.info(`[ChatClient] Skipping agent session map add for ` +
+                `guest session ${msg.session_id}`);
+            return;
+        }
         // get the correct agent session map
         const agentSessionMap = msg.team_uuid
             ? this.teams.get(msg.team_uuid)?.agentSessionMap
@@ -690,20 +761,20 @@ class ChatClient {
             throw new Error(`[addSessionToAgentSessionMap] Agent ${agentUuid}` +
                 ` not found in agent session map`);
         }
-        agentSession.sessions.push(sessionInfoToSessionData(msg));
+        agentSession.sessions.push(sessionInfoToSessionDescriptor(msg));
         agentSession.updated_at = new Date(msg.updated_at).getTime();
     }
 }
 exports.ChatClient = ChatClient;
-function sessionInfoToSessionData(msg) {
+function sessionInfoToSessionDescriptor(msg) {
     return {
         session_uuid: msg.session_id,
         title: msg.title,
         team_uuid: msg.team_uuid,
         agent_profile_uuid: msg.saved_agent_profile.uuid,
-        workspace: msg.workspace,
         updated_at: msg.updated_at,
         user_uuid: msg.owner_uuid,
+        agent_paused: msg.agent_paused,
     };
 }
 /**
@@ -723,7 +794,7 @@ function doUpdateAgentSessionMap(agentSessionMap, sessionInfo) {
     agent.sessions.map((session) => {
         if (session.session_uuid === sessionId) {
             updated = true;
-            return sessionInfoToSessionData(sessionInfo);
+            return sessionInfoToSessionDescriptor(sessionInfo);
         }
         else {
             return session;

package/dist/agent/src/chat/client/sessionClient.js

@@ -5,7 +5,10 @@ const assert_1 = require("assert");
 const uuid_1 = require("uuid");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const mcpServerManager_1 = require("../../agent/mcpServerManager");
+const messages_1 = require("../protocol/messages");
 const database_1 = require("../data/database");
+const sessionFiles_1 = require("./sessionFiles");
+const responseHandler_1 = require("./responseHandler");
 const logger = (0, sdk_1.getLogger)();
 class RemoteSudoMcpServerManager {
     constructor(sender, briefs) {
@@ -143,20 +146,27 @@ class RemoteSudoMcpServerManager {
     async shutdown() { }
 }
 class SessionClient {
-    constructor(sessionUUID, savedAgentProfile, sender, serverBriefs, participants) {
+    constructor(sessionUUID, savedAgentProfile, sender, serverBriefs, participants, agentPaused) {
+        const fileList = []; // Pass in?
         this.sessionUUID = sessionUUID;
         this.savedAgentProfile = savedAgentProfile;
         this.sender = sender;
-        this.participants = participants;
-        this.sender = sender;
         this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
+        this.sessionFiles = new sessionFiles_1.SessionFiles(sessionUUID, fileList, sender);
+        this.responseHandler = new responseHandler_1.ResponseHandler("session_error");
+        this.participants = participants;
         this.systemPrompt = "";
         this.model = "";
-        this.participants = participants;
+        this.agentPaused = agentPaused;
     }
     getSessionUUID() {
         return this.sessionUUID;
     }
+    /// This object can be queried to upload or download files, or get the
+    /// latest list. See `SessionFiles` for full usage.
+    getSessionFiles() {
+        return this.sessionFiles;
+    }
     getSudoMcpServerManager() {
         return this.smsm;
     }
@@ -187,6 +197,15 @@ class SessionClient {
         // Don't set model here.  Wait until we get confirmation from the server.
         this.sendSessionMessage({ type: "set_model", model });
     }
+    getAgentPaused() {
+        return this.agentPaused;
+    }
+    setAgentPaused(paused) {
+        this.sendSessionMessage({
+            type: "set_agent_paused",
+            paused,
+        });
+    }
     userMessage(msg, imageB64) {
         (0, assert_1.strict)(msg || imageB64, "Either message or image must be provided");
         this.sendSessionMessage({ type: "msg", message: msg, imageB64 });
@@ -249,8 +268,7 @@ class SessionClient {
         this.sender.send(enrichedMessage);
     }
     updateSessionInfo(sessionInfo) {
-        // TODO: Implement this
-        // throw new Error("[SessionClient.updateSessionInfo] not implemented");
+        // TODO: Determine the correct approach. Cache the workspace?
         const infoStr = JSON.stringify(sessionInfo.workspace);
         logger.debug(`[SessionClient] ignoring session info: ${infoStr}`);
     }
@@ -278,7 +296,24 @@ class SessionClient {
             server_name,
         });
     }
+    async shareSession() {
+        const msg = {
+            type: "share_session",
+            client_message_id: (0, uuid_1.v4)(),
+            session_id: this.sessionUUID,
+        };
+        this.sender.send(msg);
+        const response = await this.responseHandler.waitForResponse(msg);
+        if (response.type === "session_shared") {
+            return response.access_token;
+        }
+        throw new Error(`unexpected response to "share"session": ${response.type}`);
+    }
     handleMessage(message) {
+        if ((0, messages_1.isServerSessionFileMessage)(message)) {
+            this.sessionFiles.onMessage(message);
+            return;
+        }
         switch (message.type) {
             //
             // State updates
@@ -318,6 +353,12 @@ class SessionClient {
             case "user_removed":
                 this.participants.delete(message.user_uuid);
                 break;
+            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.

package/dist/agent/src/chat/client/sessionFiles.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionFiles = void 0;
+const uuid_1 = require("uuid");
+const assert_1 = require("assert");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const responseHandler_1 = require("./responseHandler");
+const logger = (0, sdk_1.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`.
+class SessionFiles {
+    constructor(sessionUUID, initialFileList, sender) {
+        this.sessionUUID = sessionUUID;
+        this.descriptors = new Map(initialFileList.map((d) => [d.name, d]));
+        this.responseHandler = new responseHandler_1.ResponseHandler(undefined);
+        this.sender = sender;
+    }
+    listFiles() {
+        return Array.from(this.descriptors.values());
+    }
+    /**
+     * Retrieve file contents.
+     */
+    async getFileContent(name) {
+        const msg = {
+            type: "session_file_get_content",
+            session_id: this.sessionUUID,
+            name,
+            client_message_id: (0, uuid_1.v4)(),
+        };
+        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) {
+        const msg = {
+            type: "session_file_delete",
+            session_id: this.sessionUUID,
+            name,
+            client_message_id: (0, uuid_1.v4)(),
+        };
+        this.sender.send(msg);
+    }
+    putFileContent(name, summary, data_url) {
+        // TODO: eventually, we could wait for a response which includes an AI
+        // assigned name.
+        (0, assert_1.strict)(name, "for now, uploaded content must have a name");
+        const msg = {
+            type: "session_file_put_content",
+            session_id: this.sessionUUID,
+            name,
+            summary,
+            data_url,
+            client_message_id: (0, uuid_1.v4)(),
+        };
+        this.sender.send(msg);
+    }
+    onMessage(msg) {
+        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 _ = msg;
+                const msgStr = JSON.stringify(msg);
+                throw new Error(`[SessionFiles.onMessage] invalid message: ${msgStr}`);
+            }
+        }
+    }
+    decodeSessionFileUrl(url) {
+        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),
+        };
+    }
+}
+exports.SessionFiles = SessionFiles;
+function removeLeadingSlashes(name) {
+    while (name.startsWith("/")) {
+        name = name.slice(1);
+    }
+    return name;
+}

package/dist/agent/src/chat/data/apiKeyManager.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiKeyManager = void 0;
 const sdk_1 = require("@xalia/xmcp/sdk");
 const logger = (0, sdk_1.getLogger)();
+const API_KEY_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 class ApiKeyManager {
     constructor(db) {
         this.db = db;
@@ -15,13 +16,43 @@ class ApiKeyManager {
         const userInfo = await this.db.getUserDataFromApiKey(apiKey);
         logger.info(`[ApiKeyManager] User info: ${JSON.stringify(userInfo)}`);
         return userInfo;
-        // if (apiKey.startsWith("dummy_key")) {
-        //   return {
-        //     user_uuid: apiKey,
-        //     nickname: apiKey,
-        //   };
-        // }
-        // return undefined;
+    }
+    /**
+     * Creates a standard api key of the form:
+     *
+     *   <prefix>_<[A-Z][a-z][0-9]+....>
+     *
+     * matching the format used in the mcppro backend
+     */
+    static createApiKey(prefix = ApiKeyManager.PREFIX, length = 32) {
+        // 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.
+     */
+    static createApiKeyWithPayload(prefix, payload, length = 32) {
+        return `${ApiKeyManager.createApiKey(prefix, length)}_${payload}`;
+    }
+    /**
+     * Parse token (containing an api and optional payload)
+     */
+    static parseToken(token) {
+        const [prefix, apiKeyVal, payload] = token.split("_");
+        const apiKey = `${prefix}_${apiKeyVal}`;
+        return { prefix, apiKey, payload };
     }
 }
 exports.ApiKeyManager = ApiKeyManager;
+ApiKeyManager.PREFIX = "xmcp";