@xalia/agent 0.6.9 → 0.6.11

package/dist/agent/src/chat/server/openAIRouterLLM.js

@@ -14,7 +14,6 @@ const DEFAULT_PROVIDER_URLS = {
     openrouter: "https://openrouter.ai/api/v1",
     openai: "https://api.openai.com/v1",
     anthropic: "https://api.anthropic.com/v1",
-    together: "https://api.together.xyz/v1",
 };
 const DEFAULT_MODEL_MAP = {
     "gpt-4o-mini": "openai",
@@ -28,8 +27,6 @@ const DEFAULT_MODEL_MAP = {
     "anthropic/claude-sonnet-4": "openrouter",
     "anthropic/claude-sonnet-4.5": "openrouter",
     "claude-3-7-sonnet-20250219": "anthropic",
-    "arcee-ai/AFM-4.5B-Preview": "together",
-    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free": "together",
 };
 let cached_maps = undefined;
 // TODO: Move this to the CLI command args?

package/dist/agent/src/chat/server/openSession.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenSession = exports.ChatSessionAgentEventHandler = exports.ChatSessionMessageSender = exports.GUEST_TOKEN_PREFIX = exports.DEFAULT_NUM_MESSGAES = void 0;
+exports.OpenSession = exports.ChatSessionAgentEventHandler = exports.ChatSessionMessageSender = exports.RACE_MODE_TIMEOUT_MS = exports.GUEST_TOKEN_PREFIX = exports.DEFAULT_NUM_MESSGAES = void 0;
 const assert_1 = require("assert");
+const uuid_1 = require("uuid");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const agent_1 = require("../../agent/agent");
 const sudoMcpServerManager_1 = require("../../agent/sudoMcpServerManager");
 const agentUtils_1 = require("../../agent/agentUtils");
+const titleGenerator_1 = require("./titleGenerator");
 const asyncQueue_1 = require("../utils/asyncQueue");
 const multiAsyncQueue_1 = require("../utils/multiAsyncQueue");
 const database_1 = require("../data/database");
@@ -15,12 +17,16 @@ const tools_1 = require("./tools");
 const chatContextManager_1 = require("./chatContextManager");
 const conversation_1 = require("./conversation");
 const sessionFileManager_1 = require("./sessionFileManager");
+const fileManager_1 = require("../../agent/tools/fileManager");
+const pdfToText_1 = require("../../agent/tools/contentExtractors/pdfToText");
+const documentSummarizer_1 = require("../../agent/documentSummarizer");
 const errorUtils_1 = require("./errorUtils");
 const nodePlatform_1 = require("../../tool/nodePlatform");
 const dbMcpServerConfigs_1 = require("../data/dbMcpServerConfigs");
 const apiKeyManager_1 = require("../data/apiKeyManager");
 const dbSessionMessages_1 = require("../data/dbSessionMessages");
 const openAIRouterLLM_1 = require("./openAIRouterLLM");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 /**
  * The model to use when the AgentProfile does not specify one.
  */
@@ -30,6 +36,7 @@ const DEFAULT_CHAT_LLM_MODEL = process.env["DEFAULT_LLM_MODEL"] || "anthropic/cl
  */
 exports.DEFAULT_NUM_MESSGAES = 500;
 exports.GUEST_TOKEN_PREFIX = "guest";
+exports.RACE_MODE_TIMEOUT_MS = 120000;
 const logger = (0, sdk_1.getLogger)();
 /**
  * Implementation of ICheckpointWriter that writes into the DB.
@@ -111,23 +118,24 @@ class ChatSessionPlatform {
     }
 }
 class ChatSessionAgentEventHandler {
-    constructor(sessionUUID, sender, approvalManager, contextTx) {
+    constructor(sessionUUID, sender, approvalManager, contextTx, alt) {
         this.sessionUUID = sessionUUID;
         this.sender = sender;
         this.approvalManager = approvalManager;
         this.contextTx = contextTx;
+        this.alt = alt;
     }
     onCompletion(result) {
-        logger.debug(`[OpenSession.onCompletion] : ${JSON.stringify(result)}`);
+        logger.debug(`[OpenSession.onCompletion] ${this.alt || ""} : ${JSON.stringify(result)}`);
         // Nothing to broadcast. Caller will receive this via onAgentMessage.
         this.contextTx.processAgentResponse(result);
     }
     onImage(image) {
-        logger.debug(`[OpenSession.onImage] : ${image.image_url.url}`);
+        logger.debug(`[OpenSession.onImage] ${this.alt || ""} : ${image.image_url.url}`);
         throw new Error("[OpenSession.onImage] unimplemented");
     }
     onToolCallResult(result) {
-        logger.debug(`[onToolCallResult] : ${JSON.stringify(result)}`);
+        logger.debug(`[onToolCallResult] ${this.alt || ""} : ${JSON.stringify(result)}`);
         const toolCallMessage = this.contextTx.processToolCallResult(result);
         this.sender.broadcast(toolCallMessage);
     }
@@ -139,12 +147,13 @@ class ChatSessionAgentEventHandler {
                 type: "tool_call",
                 tool_call: toolCall,
                 session_id: this.sessionUUID,
+                ...(this.alt ? { alt: this.alt } : {}),
             });
             return true;
         }
         // TODO: Need a proper mapping to/from MCP calls to tool names
         const [serverName, tool] = toolCall.function.name.split("__");
-        const { approved, requested } = await this.approvalManager.getApproval(serverName, tool, toolCall);
+        const { approved, requested } = await this.approvalManager.getApproval(serverName, tool, toolCall, this.alt);
         // For now, the frontend uses the tool_call data in the
         // "approve_tool_call" request to display the tool call data.  If approval
         // was requested in this way, don't send the "tool_call" message as well.
@@ -153,25 +162,31 @@ class ChatSessionAgentEventHandler {
                 type: "tool_call",
                 tool_call: toolCall,
                 session_id: this.sessionUUID,
+                ...(this.alt ? { alt: this.alt } : {}),
             });
         }
         return approved;
     }
     onAgentMessage(msg, end) {
-        logger.debug(`[OpenSession.onAgentMessage] msg: ${msg}, end: ${String(end)}`);
+        logger.debug(`[OpenSession.onAgentMessage] ${this.alt || ""} msg: ${msg}, ` +
+            `end: ${String(end)}`);
         // Inform the contextManager and broadcast the ServerAgentMessageChunk
         const agentMsgChunk = this.contextTx.processAgentMessageChunk(msg, end);
+        if (this.alt) {
+            agentMsgChunk.alt = this.alt;
+        }
         this.sender.broadcast(agentMsgChunk);
         return Promise.resolve();
     }
     onReasoning(reasoning) {
         return new Promise((r) => {
-            logger.debug(`[OpenSession.onReasoning]${reasoning}`);
+            logger.debug(`[OpenSession.onReasoning] ${this.alt || ""} ${reasoning}`);
             if (reasoning.length > 0) {
                 this.sender.broadcast({
                     type: "agent_reasoning_chunk",
                     reasoning,
                     session_id: this.sessionUUID,
+                    ...(this.alt ? { alt: this.alt } : {}),
                 });
             }
             r();
@@ -190,7 +205,7 @@ exports.ChatSessionAgentEventHandler = ChatSessionAgentEventHandler;
  * tool approvals and other interactions).
  */
 class OpenSession {
-    constructor(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, agentProfilePreferences, skillManager, contextManager, sender, approvalManager, fileManager) {
+    constructor(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, agentProfilePreferences, skillManager, contextManager, sender, approvalManager, fileManager, platform) {
         this.db = db;
         this.agent = agent;
         this.sessionUUID = sessionData.session_uuid;
@@ -208,10 +223,13 @@ class OpenSession {
         this.approvalManager = approvalManager;
         this.savedAgentProfile = savedAgentProfile;
         this.sessionFileManager = fileManager;
+        this.platform = platform;
+        this.raceModeAwaiter = responseAwaiter_1.ResponseAwaiter.init(undefined, (m) => m.message_id, exports.RACE_MODE_TIMEOUT_MS);
         this.isPersisted = isPersisted;
         this.sessionTitle = sessionData.title;
         this.sessionUpdatedAt = sessionData.updated_at;
         this.agentPaused = sessionData.agent_paused;
+        this.titleGenerator = (0, titleGenerator_1.createTitleGenerator)();
         fileManager.addEventHandler(this);
         this.updateParticipantsPrompt();
     }
@@ -222,8 +240,8 @@ class OpenSession {
         const platform = new ChatSessionPlatform(sender, sessionId, ownerData.uuid);
         const toolApprovalManager = new approvalManager_1.ToolApprovalManager(sessionData.session_uuid, savedAgentProfile.uuid, savedAgentProfile.preferences, sender, new approvalManager_1.DbAgentPreferencesWriter(db));
         const checkpointWriter = new DBCheckpointWriter(db, sessionId);
-        const { agent, skillManager, contextManager } = await createContextAndAgent(sessionId, savedAgentProfile.profile.system_prompt, savedAgentProfile.profile.model || DEFAULT_CHAT_LLM_MODEL, sessionMessages, sessionData.workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter);
-        const openSession = new OpenSession(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, savedAgentProfile.preferences, skillManager, contextManager, sender, toolApprovalManager, fileManager);
+        const { agent, skillManager, contextManager } = await createContextAndAgent(sessionId, savedAgentProfile.profile.system_prompt, savedAgentProfile.profile.model || DEFAULT_CHAT_LLM_MODEL, sessionMessages, sessionData.workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter, sender);
+        const openSession = new OpenSession(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, savedAgentProfile.preferences, skillManager, contextManager, sender, toolApprovalManager, fileManager, platform);
         // Note, MCP servers have not been enabled yet
         return openSession;
     }
@@ -298,7 +316,9 @@ class OpenSession {
             });
         });
         // send conversation history
-        const conversationMessages = this.contextManager.getConversationMessages();
+        const conversationMessages = this.contextManager
+            .getConversationMessages()
+            .concat(this.userMessageQueue.getEntries());
         conversationMessages.forEach((message) => {
             connMgr.sendToConnection(connectionId, message);
         });
@@ -381,30 +401,25 @@ class OpenSession {
                 this.sender.broadcast(msg);
             }
         };
+        let errorMessage;
         if (err instanceof errors_1.ChatFatalError) {
             // ChatFatalError in session context should send error to specific user
             // or broadcast if no specific user context
-            sendError({
-                type: "session_error",
-                message: err.message,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = err.message;
         }
         else if (err instanceof errors_1.ChatErrorMessage) {
-            sendError({
-                type: "session_error",
-                message: err.message,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = err.message;
         }
         else {
-            const errString = (0, errorUtils_1.getErrorString)(err);
-            sendError({
-                type: "session_error",
-                message: errString,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = (0, errorUtils_1.getErrorString)(err);
         }
+        logger.error(`[OpenSession.handleError] sessionUUID=${this.sessionUUID} ` +
+            `from=${from ?? "broadcast"}: ${errorMessage}`);
+        sendError({
+            type: "session_error",
+            message: errorMessage,
+            session_id: this.sessionUUID,
+        });
         return true;
     }
     // ISessionFileManagerEventHandler.onFileDeleted
@@ -415,6 +430,15 @@ class OpenSession {
             name,
         });
     }
+    broadcastContextUsage() {
+        const { used, max } = this.contextManager.getContextUsage();
+        this.sender.broadcast({
+            type: "context_usage",
+            session_id: this.sessionUUID,
+            used_tokens: used,
+            max_tokens: max,
+        });
+    }
     // ISessionFileManagerEventHandler.onFileChanged
     onFileChanged(entry, new_file) {
         this.sender.broadcast({
@@ -493,6 +517,9 @@ class OpenSession {
                 case "msg":
                     broadcastMsg = await this.handleUserMessage(msg, queuedMessage.from);
                     break;
+                case "stop":
+                    this.agent.stop();
+                    break;
                 case "add_mcp_server":
                     broadcastMsg = await this.handleAddMcpServer(msg.server_name, msg.enable_all);
                     break;
@@ -547,6 +574,9 @@ class OpenSession {
                 case "get_mcp_resource":
                     void this.handleGetMcpResource(msg, queuedMessage.from);
                     break;
+                case "race_mode_result":
+                    this.raceModeAwaiter.onMessage(msg);
+                    break;
                 default: {
                     const exhaustive = msg; // Error => non-exhaustive switch-case.
                     return exhaustive;
@@ -560,6 +590,10 @@ class OpenSession {
                 }
                 else {
                     this.sender.broadcast(broadcastMsg);
+                    // Broadcast context usage after user message
+                    if (broadcastMsg.type === "user_msg") {
+                        this.broadcastContextUsage();
+                    }
                 }
             }
         }
@@ -618,12 +652,11 @@ class OpenSession {
         // Just send the user LLM user messages direct to the ContextManager, so
         // they are available to the LLM once it is restarted.
         const { contextTx } = await this.contextManager.startAgentResponse(msgs);
-        return this.contextManager.endAgentResponse(contextTx);
+        const result = this.contextManager.endAgentResponse(contextTx);
+        this.broadcastContextUsage();
+        return result;
     }
     async processUserMessagesActive(msgs) {
-        // TODO: create the contextTx and store all new messages on this.  Event
-        // handler should accept the contextTx and forward messages to it, as well
-        // as sending the updates.
         // All accumulated messages (DB, Protocol and LLM) should be on the
         // specialized contextTx.
         const { contextTx, agentFirstChunk } = await this.contextManager.startAgentResponse(msgs);
@@ -641,13 +674,77 @@ class OpenSession {
             // DB.  Should we keep them?
             throw new Error(errMsg);
         }
-        return this.contextManager.endAgentResponse(contextTx);
+        const result = this.contextManager.endAgentResponse(contextTx);
+        this.broadcastContextUsage();
+        return result;
+    }
+    /**
+     * `processUserMessage` logic for race-mode.
+     */
+    async processUserMessagesRaceMode(msgs) {
+        // Create a second agent, same skillManager
+        const modelB = msgs[0].race_mode;
+        (0, assert_1.strict)(typeof modelB === "string");
+        const agentB = await (async () => {
+            try {
+                const llmB = await createLLM(modelB, this.platform);
+                return new agent_1.AgentEx(this.skillManager, llmB);
+            }
+            catch (e) {
+                logger.warn("[OpenSession.processUserMessages] error creating race agent: " +
+                    String(e));
+                throw new Error(`error creating race: ${String(e)}`);
+            }
+        })();
+        const run = async (alt, msgs) => {
+            const { contextTx: contextTx, agentFirstChunk: agentFirstChunk } = await this.contextManager.startAgentResponse(msgs.slice());
+            this.sender.broadcast(agentFirstChunk);
+            const eventHandler = new ChatSessionAgentEventHandler(this.sessionUUID, this.sender, this.approvalManager, contextTx, alt);
+            try {
+                const agent = alt === "B" ? agentB : this.agent;
+                await agent.userMessagesRaw(contextTx, eventHandler);
+            }
+            catch (e) {
+                logger.warn(`[OpenSession.processUserMessages] agent ${alt} error: ${String(e)}`);
+                const errMsg = `error from LLM: ${String(e)}`;
+                contextTx.revertAgentResponse(errMsg);
+                throw new Error(errMsg);
+            }
+            return contextTx;
+        };
+        const [txA, txB] = await Promise.all([
+            run("A", msgs.slice()),
+            run("B", msgs),
+        ]);
+        // Ask which fork to commit
+        const answer = await (async () => {
+            const message_id = (0, uuid_1.v4)();
+            const answerP = this.raceModeAwaiter.waitForResponse(message_id);
+            const getResultMsg = {
+                type: "race_mode_get_result",
+                message_id,
+                alts: ["A", "B"],
+                session_id: this.sessionUUID,
+            };
+            this.sender.broadcast(getResultMsg);
+            return answerP;
+        })();
+        if (answer.result === "A") {
+            return this.contextManager.endAgentResponse(txA);
+        }
+        else {
+            return this.contextManager.endAgentResponse(txB);
+        }
+        // UI is responsible for switching model if the user wants to.
     }
     async processUserMessages(msgs) {
+        logger.debug(`[processUserMessages] msgs: ${JSON.stringify(msgs)}`);
         try {
             const newSessionMessages = this.agentPaused
                 ? await this.processUserMessagePaused(msgs)
-                : await this.processUserMessagesActive(msgs);
+                : await (msgs[0].race_mode
+                    ? this.processUserMessagesRaceMode(msgs)
+                    : this.processUserMessagesActive(msgs));
             logger.debug("[processUserMessages] newSessionMessages: " +
                 JSON.stringify(newSessionMessages));
             // Append to in-memory conversation and write to the DB
@@ -655,6 +752,8 @@ class OpenSession {
             await dbsm.append(this.sessionUUID, newSessionMessages);
         }
         catch (e) {
+            logger.error(`[processUserMessages] ERROR session=${this.sessionUUID}: ` +
+                String(e));
             if (!this.handleError(e)) {
                 throw e;
             }
@@ -664,9 +763,16 @@ class OpenSession {
         // Return a ServerUserMessage for broadcast.  The actual message is places
         // on a queue to be dealt with in another loop.  This allows Agent
         // processing of user messages to depend on other messages.
-        (0, assert_1.strict)(msg);
-        (0, assert_1.strict)(from);
-        // Assign the user message_idx and attempt to enqueue.
+        (0, assert_1.strict)(msg, "undefined user message");
+        (0, assert_1.strict)(from, "undefined user message sender");
+        logger.info(`[handleUserMessage] msg.attachedFiles: ${JSON.stringify(msg.attachedFiles
+            ? msg.attachedFiles.map((f) => ({
+                name: f.name,
+                data_url_length: f.data_url.length,
+            }))
+            : "none")}`);
+        // Assign the user message_idx first so we can check if this is
+        // the first message
         const user = this.sessionParticipants.get(from);
         if (!user) {
             throw new Error(`unrecognized user ${from}`);
@@ -675,6 +781,62 @@ class OpenSession {
         if (!userMessage) {
             return;
         }
+        // Handle attached files by adding them to session files
+        if (msg.attachedFiles && msg.attachedFiles.length > 0) {
+            const fileCount = String(msg.attachedFiles.length);
+            logger.info(`[handleUserMessage] Processing ${fileCount} attached files`);
+            // If this is the first message, set the session title before
+            // creating the session
+            if (userMessage.message_idx === conversation_1.MESSAGE_INDEX_START_VALUE &&
+                !this.isPersisted) {
+                this.sessionTitle = userMessage.message?.slice(0, 128) || "New Chat";
+            }
+            // If the session hasn't been persisted, it must be written to
+            // the DB first
+            if (!this.isPersisted) {
+                await this.createSessionInDB();
+            }
+            // Add each attached file to session files
+            for (const file of msg.attachedFiles) {
+                logger.info(`[handleUserMessage] Adding file ${file.name} to session files`);
+                // Extract content and generate summary for PDFs
+                let parsed_content;
+                let summary;
+                const mimeType = (0, fileManager_1.getMimeTypeFromDataUrl)(file.data_url);
+                if (mimeType === "application/pdf") {
+                    try {
+                        // Extract base64 data and convert to ArrayBuffer
+                        const base64Data = file.data_url.split(",")[1];
+                        const binaryString = atob(base64Data);
+                        const bytes = new Uint8Array(binaryString.length);
+                        for (let i = 0; i < binaryString.length; i++) {
+                            bytes[i] = binaryString.charCodeAt(i);
+                        }
+                        const arrayBuffer = bytes.buffer;
+                        // Extract text from PDF
+                        const extractedText = await (0, pdfToText_1.pdfToText)(arrayBuffer);
+                        parsed_content = {
+                            version: 1,
+                            text: extractedText,
+                        };
+                        // Generate summary from extracted text
+                        if (extractedText.trim().length > 0) {
+                            summary = await (0, documentSummarizer_1.summarizeDocument)(extractedText);
+                        }
+                        logger.info(`[handleUserMessage] Extracted ${String(extractedText.length)}` +
+                            ` chars from PDF ${file.name}`);
+                    }
+                    catch (err) {
+                        logger.warn(`[handleUserMessage] Failed to extract PDF content: ` +
+                            String(err));
+                    }
+                }
+                await this.sessionFileManager.putFileContent(file.name, summary, file.data_url, parsed_content);
+            }
+            // Remove attachedFiles from the message so they don't get
+            // included in the LLM context
+            msg = { ...msg, attachedFiles: undefined };
+        }
         // Special case for the first message of the session
         if (userMessage.message_idx === conversation_1.MESSAGE_INDEX_START_VALUE) {
             // No need to wait for this to complete before broadcasting.
@@ -714,8 +876,8 @@ class OpenSession {
         this.isPersisted = true;
     }
     async onFirstMessage(userMsg) {
-        // Update title on the class before writing to the DB
-        this.sessionTitle = userMsg.message?.slice(0, 128) || "New Chat";
+        // Generate title using LLM with automatic fallback
+        this.sessionTitle = await this.titleGenerator.generateTitle(userMsg.message || "");
         // The session may already have been saved (e.g. if the workspace is
         // updated before any messages are sent).
         if (!this.isPersisted) {
@@ -1080,27 +1242,28 @@ async function loadSessionData(db, sessionId) {
         sessionParticipants: (0, database_1.createSessionParticipantMap)(sessionParticipants),
     };
 }
-async function createContextAndAgent(sessionUUID, systemPrompt, model, sessionMessages, workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter) {
-    // Fn to create the llm.  One invocation for the compression context, one
-    // for the Agent.
-    const createLLM = async () => {
-        let llm = await (0, agentUtils_1.createSpecializedLLM)(model, platform);
-        if (!llm) {
-            llm = new openAIRouterLLM_1.OpenAIRouterLLM(model);
-        }
-        (0, assert_1.strict)(llm);
-        return llm;
-    };
-    const contextManager = new chatContextManager_1.ChatContextManager(systemPrompt, sessionMessages, sessionUUID, ownerData.uuid, sessionCheckpoint, checkpointWriter, fileManager, await createLLM());
-    if (workspace) {
-        contextManager.setWorkspace((0, agent_1.createUserMessage)(workspace.message, workspace.imageB64));
+async function createLLM(model, platform) {
+    let llm = await (0, agentUtils_1.createSpecializedLLM)(model, platform);
+    if (!llm) {
+        llm = new openAIRouterLLM_1.OpenAIRouterLLM(model);
     }
+    (0, assert_1.strict)(llm);
+    return llm;
+}
+async function createContextAndAgent(sessionUUID, systemPrompt, model, sessionMessages, workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter, messageSender) {
+    // Create SkillManager
     const xmcpConfig = sdk_1.Configuration.new(ownerApiKey, xmcpUrl, false);
     const skillManager = await sudoMcpServerManager_1.SkillManager.initialize((url, authResultP, displayName) => {
         platform.openUrl(url, authResultP, displayName);
     }, xmcpConfig.backend_url, xmcpConfig.api_key, undefined /* authorizedUrl */);
-    const llm = await createLLM();
+    // Fn to create the llm.  One invocation for the compression context, one
+    // for the Agent.
+    const llm = await createLLM(model, platform);
     const agent = new agent_1.AgentEx(skillManager, llm);
-    await (0, tools_1.addDefaultChatTools)(agent, ownerData.timezone, platform, fileManager);
+    await (0, tools_1.addDefaultChatTools)(agent, ownerData.timezone, platform, fileManager, messageSender);
+    const contextManager = new chatContextManager_1.ChatContextManager(systemPrompt, sessionMessages, sessionUUID, ownerData.uuid, sessionCheckpoint, checkpointWriter, fileManager, await createLLM(model, platform));
+    if (workspace) {
+        contextManager.setWorkspace((0, agent_1.createUserMessage)(workspace.message, workspace.imageB64));
+    }
     return { agent, skillManager, contextManager };
 }

package/dist/agent/src/chat/server/promptRefiner.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMPromptRefiner = void 0;
+exports.getPromptRefiner = getPromptRefiner;
+const openAIRouterLLM_1 = require("./openAIRouterLLM");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const logger = (0, sdk_1.getLogger)();
+const REFINER_MODEL = "google/gemini-2.5-flash";
+const REFINER_MAX_TOKENS = 2000;
+const REFINER_TEMPERATURE = 0.3;
+const REFINER_TIMEOUT_MS = 30000;
+// prettier-ignore
+const REFINEMENT_SYSTEM_PROMPT = `You are an expert at writing system prompts for AI assistants. Your task is \
+to refine and improve the given system prompt to make it more effective, \
+clear, and well-structured for an LLM to follow.
+
+Guidelines for refinement:
+1. Make instructions clear, specific, and actionable
+2. Use structured formatting (sections, bullet points) when appropriate
+3. Remove ambiguity and redundancy
+4. Add relevant context if missing
+5. Ensure the tone and style are consistent
+6. Preserve the original intent and personality
+7. Keep the prompt concise but comprehensive
+
+Return ONLY the refined system prompt, without any explanations or \
+meta-commentary.`;
+class LLMPromptRefiner {
+    constructor(model = REFINER_MODEL) {
+        this.model = model;
+    }
+    async refinePrompt(prompt) {
+        if (!prompt || prompt.trim().length === 0) {
+            return prompt;
+        }
+        try {
+            const refined = await this.refineWithTimeout(prompt);
+            return refined.trim();
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.warn(`[PromptRefiner] LLM refinement failed: ${errorMsg}, returning original`);
+            throw error;
+        }
+    }
+    async refineWithTimeout(prompt) {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error("Prompt refinement timeout"));
+            }, REFINER_TIMEOUT_MS);
+        });
+        const refinePromise = this.callLLM(prompt);
+        return Promise.race([refinePromise, timeoutPromise]);
+    }
+    async callLLM(prompt) {
+        const client = (0, openAIRouterLLM_1.getOpenAIClient)(this.model);
+        const response = await client.chat.completions.create({
+            model: this.model,
+            messages: [
+                {
+                    role: "system",
+                    content: REFINEMENT_SYSTEM_PROMPT,
+                },
+                {
+                    role: "user",
+                    content: `Please refine this system prompt:\n\n${prompt}`,
+                },
+            ],
+            max_tokens: REFINER_MAX_TOKENS,
+            temperature: REFINER_TEMPERATURE,
+        });
+        const refined = response.choices[0]?.message?.content?.trim();
+        if (!refined) {
+            throw new Error("Empty response from LLM");
+        }
+        return refined;
+    }
+}
+exports.LLMPromptRefiner = LLMPromptRefiner;
+let promptRefinerInstance;
+function getPromptRefiner(model) {
+    if (!promptRefinerInstance) {
+        promptRefinerInstance = new LLMPromptRefiner(model);
+    }
+    return promptRefinerInstance;
+}

package/dist/agent/src/chat/server/server.js

@@ -47,8 +47,12 @@ const database_1 = require("../data/database");
 const errors_1 = require("../protocol/errors");
 const sessionRegistry_1 = require("./sessionRegistry");
 const DEVELOPMENT = process.env.DEVELOPMENT === "1";
+const TEST = process.env.TEST === "1";
 dotenv.config();
-if (DEVELOPMENT) {
+if (TEST) {
+    dotenv.config({ path: ".env.test" });
+}
+else if (DEVELOPMENT) {
     dotenv.config({ path: ".env.development" });
 }
 const logger = (0, sdk_1.getLogger)();