@xalia/agent 0.6.8 → 0.6.10

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMTitleGenerator = void 0;
+exports.createTitleGenerator = createTitleGenerator;
+const openAIRouterLLM_1 = require("./openAIRouterLLM");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const logger = (0, sdk_1.getLogger)();
+const TITLE_MODEL = "google/gemini-2.5-flash";
+const TITLE_MAX_TOKENS = 20;
+const TITLE_TEMPERATURE = 0.2;
+const TITLE_TIMEOUT_MS = 5000;
+const MAX_TITLE_LENGTH = 120;
+const TITLE_SYSTEM_PROMPT = `You create ultra-short, descriptive titles for user prompts.
+Rules:
+- Maximum 8 words
+- No punctuation except spaces and hyphens
+- No quotes or special characters
+- Use Title Case
+- Output ONLY the title text
+- Be descriptive and capture the main intent`;
+class LLMTitleGenerator {
+    constructor(model = TITLE_MODEL) {
+        this.model = model;
+    }
+    async generateTitle(firstUserMessage) {
+        if (!firstUserMessage || firstUserMessage.trim().length === 0) {
+            return "New Chat";
+        }
+        try {
+            const title = await this.generateTitleWithTimeout(firstUserMessage);
+            return this.sanitizeTitle(title);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.warn(`[TitleGenerator] LLM title generation failed: ${errorMsg}, ` +
+                `using fallback`);
+            return this.fallbackTitle(firstUserMessage);
+        }
+    }
+    async generateTitleWithTimeout(message) {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error("Title generation timeout"));
+            }, TITLE_TIMEOUT_MS);
+        });
+        const titlePromise = this.callLLM(message);
+        return Promise.race([titlePromise, timeoutPromise]);
+    }
+    async callLLM(message) {
+        const client = (0, openAIRouterLLM_1.getOpenAIClient)(this.model);
+        const truncatedMessage = message.slice(0, 500);
+        const response = await client.chat.completions.create({
+            model: this.model,
+            messages: [
+                {
+                    role: "system",
+                    content: TITLE_SYSTEM_PROMPT,
+                },
+                {
+                    role: "user",
+                    content: `User prompt: ${truncatedMessage}`,
+                },
+            ],
+            max_tokens: TITLE_MAX_TOKENS,
+            temperature: TITLE_TEMPERATURE,
+        });
+        const title = response.choices[0]?.message?.content?.trim();
+        if (!title) {
+            throw new Error("Empty response from LLM");
+        }
+        return title;
+    }
+    sanitizeTitle(title) {
+        let sanitized = title
+            .replace(/["'`]/g, "")
+            .replace(/\n/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (sanitized.length > MAX_TITLE_LENGTH) {
+            sanitized = sanitized.slice(0, MAX_TITLE_LENGTH).trim();
+        }
+        return sanitized || "New Chat";
+    }
+    fallbackTitle(message) {
+        const cleaned = message.trim();
+        if (cleaned.length === 0) {
+            return "New Chat";
+        }
+        const firstSentence = cleaned.split(/[.!?]\s/)[0];
+        const titleCandidate = firstSentence.length <= MAX_TITLE_LENGTH
+            ? firstSentence
+            : cleaned.slice(0, MAX_TITLE_LENGTH);
+        return titleCandidate.trim() || "New Chat";
+    }
+}
+exports.LLMTitleGenerator = LLMTitleGenerator;
+class FallbackTitleGenerator {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async generateTitle(firstUserMessage) {
+        const cleaned = firstUserMessage.trim();
+        if (cleaned.length === 0) {
+            return "New Chat";
+        }
+        return cleaned.slice(0, 120) || "New Chat";
+    }
+}
+function createTitleGenerator(model) {
+    if (process.env.DISABLE_LLM_TITLES === "true") {
+        return new FallbackTitleGenerator();
+    }
+    return new LLMTitleGenerator(model);
+}

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

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const titleGenerator_1 = require("./titleGenerator");
+const openAIRouterLLM = __importStar(require("./openAIRouterLLM"));
+vitest_1.vi.mock("./openAIRouterLLM", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getOpenAIClient: vitest_1.vi.fn(),
+    };
+});
+vitest_1.vi.mock("@xalia/xmcp/sdk", () => ({
+    getLogger: () => ({
+        info: vitest_1.vi.fn(),
+        warn: vitest_1.vi.fn(),
+        error: vitest_1.vi.fn(),
+        debug: vitest_1.vi.fn(),
+    }),
+}));
+(0, vitest_1.describe)("LLMTitleGenerator", () => {
+    let generator;
+    let mockCreate;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        mockCreate = vitest_1.vi.fn();
+        vitest_1.vi.mocked(openAIRouterLLM.getOpenAIClient).mockReturnValue({
+            chat: {
+                completions: {
+                    create: mockCreate,
+                },
+            },
+        });
+        generator = new titleGenerator_1.LLMTitleGenerator();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)("should generate and sanitize title from LLM", async () => {
+        mockCreate.mockResolvedValue({
+            choices: [{ message: { content: '"Title\nWith   Issues"' } }],
+        });
+        const title = await generator.generateTitle("Test message");
+        (0, vitest_1.expect)(title).toBe("Title With Issues");
+        (0, vitest_1.expect)(mockCreate).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            max_tokens: 20,
+            temperature: 0.2,
+        }));
+    });
+    (0, vitest_1.it)("should fallback on LLM failure", async () => {
+        mockCreate.mockRejectedValue(new Error("API error"));
+        const title = await generator.generateTitle("First sentence. Second sentence.");
+        (0, vitest_1.expect)(title).toBe("First sentence");
+    });
+    (0, vitest_1.it)("should handle empty messages", async () => {
+        (0, vitest_1.expect)(await generator.generateTitle("")).toBe("New Chat");
+        (0, vitest_1.expect)(await generator.generateTitle("   ")).toBe("New Chat");
+        (0, vitest_1.expect)(mockCreate).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("should enforce 120 char limit on both LLM and fallback", async () => {
+        const longText = "A".repeat(150);
+        mockCreate.mockResolvedValue({
+            choices: [{ message: { content: longText } }],
+        });
+        const llmTitle = await generator.generateTitle("Test");
+        (0, vitest_1.expect)(llmTitle.length).toBe(120);
+        mockCreate.mockRejectedValue(new Error("fail"));
+        const fallbackTitle = await generator.generateTitle(longText);
+        (0, vitest_1.expect)(fallbackTitle.length).toBe(120);
+    });
+    (0, vitest_1.it)("should use fallback when DISABLE_LLM_TITLES is true", async () => {
+        const originalEnv = process.env.DISABLE_LLM_TITLES;
+        process.env.DISABLE_LLM_TITLES = "true";
+        const fallbackGenerator = (0, titleGenerator_1.createTitleGenerator)();
+        const title = await fallbackGenerator.generateTitle("Hello from User 1");
+        (0, vitest_1.expect)(title).toBe("Hello from User 1");
+        (0, vitest_1.expect)(mockCreate).not.toHaveBeenCalled();
+        process.env.DISABLE_LLM_TITLES = originalEnv;
+    });
+});

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

@@ -1,271 +1,78 @@
 "use strict";
 /**
- * Collection of simple Agent tools.
+ * Chat-specific agent tools.
+ *
+ * This file contains chat-specific tools like image generation and test tools.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testTool = exports.calculatorTool = void 0;
-exports.makeParseArgsFn = makeParseArgsFn;
-exports.isoWithTimezone = isoWithTimezone;
-exports.datetimeTool = datetimeTool;
-exports.calculatorEval = calculatorEval;
-exports.renderTool = renderTool;
-exports.webSearchTool = webSearchTool;
-exports.openURL = openURL;
-exports.openURLTool = openURLTool;
+exports.testTool = void 0;
+exports.editTextTool = editTextTool;
 exports.addDefaultChatTools = addDefaultChatTools;
-const expr_eval_1 = require("expr-eval");
-const sdk_1 = require("@xalia/xmcp/sdk");
-const htmlToText_1 = require("../utils/htmlToText");
-const search_1 = require("../utils/search");
-const sessionFileManager_1 = require("./sessionFileManager");
+const tools_1 = require("../../agent/tools");
 const imageGeneratorTools_1 = require("./imageGeneratorTools");
-const logger = (0, sdk_1.getLogger)();
 const DEVELOPMENT = process.env.DEVELOPMENT === "1";
-/**
- * Returns a function which parses an `args` struct and attempts to extract
- * multiple string parameters with the given names.  e.g.
- *
- *   const parseFn = makeParseArgsFn(
- *     ["arg0", "arg1"] as const,
- *     ["opt0"] as const)
- *
- * creates
- *
- *   parseFn: (args: unknown) => {
- *     arg0: string,
- *     arg1: string,
- *     opt0: string|undefined
- *   }
- *
- * which can be used to parse tool arguments.
- *
- * NOTE, the complex type parameters ensures that the name list is a
- * compile-time value, which in turn ensures that the return value of this
- * function is well-typed.
- */
-function makeParseArgsFn(names, optNames) {
-    return (args) => {
-        if (!args || typeof args !== "object") {
-            throw new Error(`invalid args: ${typeof args}`);
-        }
-        const argsObj = args;
-        for (const name of names) {
-            const val = argsObj[name];
-            if (typeof val !== "string") {
-                throw new Error(`invalid expr args.${name}: ${typeof val}`);
-            }
-        }
-        if (optNames) {
-            for (const name of optNames) {
-                const val = argsObj[name];
-                if (typeof val !== "undefined" && typeof val !== "string") {
-                    throw new Error(`invalid expr args.${name}: ${typeof val}`);
-                }
-            }
-        }
-        return argsObj;
-    };
-}
-const DATETIME_DESC = {
-    type: "function",
-    function: {
-        name: "time_now",
-        description: "Current time",
-    },
-};
-function isoWithTimezone(timeZone) {
-    return (new Intl.DateTimeFormat("sv-SE", {
-        timeZone,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-        hour12: false,
-        timeZoneName: "short",
-    })
-        .format(new Date())
-        .replace(" ", "T") + ` (${timeZone})`);
-}
-function datetimeTool(timezone) {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    const toolFn = async () => {
-        return { response: isoWithTimezone(timezone) };
-    };
-    return {
-        // eslint-disable-next-line @typescript-eslint/require-await
-        setup: async (agent) => {
-            agent.addAgentTool(DATETIME_DESC, toolFn);
-        },
-    };
-}
-const ARITHMETIC_DESC = {
+const TEST = process.env.TEST === "1";
+const EDIT_TEXT_DESC = {
     type: "function",
     function: {
-        name: "arithmetic",
-        description: "Evaluate arithmetic expression",
+        name: "edit_text",
+        description: "Modify text in the user's editor. Use this to write, update, " +
+            "or add content to the editor when the user asks you to create or " +
+            "edit text content. If the user quoted text from the editor, use " +
+            "'replace_selection' to modify only that quoted text.",
         parameters: {
             type: "object",
             properties: {
-                expr: {
-                    type: "string",
-                    description: "Expression containing +-*/()",
-                },
-            },
-            required: ["expr"],
-        },
-    },
-};
-function calculatorEval(args) {
-    try {
-        return String(expr_eval_1.Parser.evaluate(args));
-    }
-    catch (e) {
-        if (typeof e.message === "string") {
-            return e.message;
-        }
-        return String(e);
-    }
-}
-exports.calculatorTool = {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent) => {
-        const getExpr = makeParseArgsFn(["expr"]);
-        // eslint-disable-next-line @typescript-eslint/require-await
-        const toolFn = async (_, args) => {
-            const { expr } = getExpr(args);
-            return { response: calculatorEval(expr) };
-        };
-        agent.addAgentTool(ARITHMETIC_DESC, toolFn);
-    },
-};
-const RENDER_DESC = {
-    type: "function",
-    function: {
-        name: "render",
-        description: "Display the given html fragment inside a div element",
-        parameters: {
-            type: "object",
-            properties: {
-                name: {
-                    type: "string",
-                    description: "Filename to store the html",
-                },
-                summary: {
+                operation: {
                     type: "string",
-                    description: "One line summary",
+                    enum: ["replace", "append", "prepend", "replace_selection"],
+                    description: "How to modify the editor: 'replace' to overwrite all " +
+                        "content, 'append' to add at the end, 'prepend' to add at " +
+                        "the beginning, 'replace_selection' to replace the " +
+                        "quoted/selected text",
                 },
-                html: {
+                content: {
                     type: "string",
-                    description: "HTML fragment to render",
+                    description: "The markdown content to set or add to the editor",
                 },
             },
-            required: ["name", "summary", "html"],
+            required: ["operation", "content"],
         },
     },
 };
-function renderTool(fileManager) {
-    const getNameSummeryHtml = makeParseArgsFn([
-        "name",
-        "summary",
-        "html",
-    ]);
-    const toolFn = async (_, args) => {
-        const { name, summary, html } = getNameSummeryHtml(args);
-        const mimeType = "text/html";
-        const dataURL = `data:${mimeType},${html}`;
-        await fileManager.putFileContent(name, summary, dataURL);
-        const uri = fileManager.getSessionFileRelativeUrl(name);
-        return {
-            response: "",
-            _meta: { "xalia/fileUri": uri, "xalia/fileMimeType": mimeType },
-        };
-    };
-    return {
-        // eslint-disable-next-line @typescript-eslint/require-await
-        setup: async (agent) => {
-            agent.addAgentTool(RENDER_DESC, toolFn);
-        },
-    };
-}
-const WEB_SEARCH_DESC = {
-    type: "function",
-    function: {
-        name: "web_search",
-        description: "Web search",
-        parameters: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query text",
-                },
-            },
-            required: ["query"],
-        },
-    },
-};
-function webSearchTool() {
-    const getQuery = makeParseArgsFn(["query"]);
-    const toolFn = async (_, args) => {
-        const { query } = getQuery(args);
-        logger.debug(`[web_search]: query: ${query}`);
-        const results = await (0, search_1.webSearch)(query);
-        logger.debug(`[web_search]: results: ${results}`);
-        return { response: JSON.stringify(results) };
-    };
-    return {
-        // eslint-disable-next-line @typescript-eslint/require-await
-        setup: async (agent) => {
-            agent.addAgentTool(WEB_SEARCH_DESC, toolFn);
-        },
-    };
-}
-// open_url
-/**
- * For now, this matches the duckduckgo-mcp-server length.  Could extend
- * depending on the application / model etc.
- */
-const _OPEN_URL_MAX_LENGTH_STR = process.env["OPEN_URL_MAX_LENGTH"] || "8000";
-const OPEN_URL_MAX_LENGTH = parseInt(_OPEN_URL_MAX_LENGTH_STR, 10);
-const OPEN_URL_DESC = {
-    type: "function",
-    function: {
-        name: "open_url",
-        description: "Download content from a URL",
-        parameters: {
-            type: "object",
-            properties: {
-                url: {
-                    type: "string",
-                    description: "URL to download",
-                },
-            },
-            required: ["url"],
-        },
-    },
-};
-async function openURL(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        const status = String(response.status);
-        const code = response.statusText;
-        throw new Error(`Failed to fetch ${url}: ${status} ${code}`);
-    }
-    const html = await response.text();
-    return (0, htmlToText_1.htmlToText)(html, OPEN_URL_MAX_LENGTH);
-}
-function openURLTool() {
-    const getURL = makeParseArgsFn(["url"]);
-    const toolFn = async (_, args) => {
-        const { url } = getURL(args);
-        return { response: await openURL(url) };
+const VALID_OPERATIONS = [
+    "replace",
+    "append",
+    "prepend",
+    "replace_selection",
+];
+function editTextTool(messageSender) {
+    const parseArgs = (0, tools_1.makeParseArgsFn)(["operation", "content"]);
+    const toolFn = (_, args) => {
+        const { operation, content } = parseArgs(args);
+        // Validate operation
+        if (!VALID_OPERATIONS.includes(operation)) {
+            return Promise.resolve({
+                response: `Invalid operation: ${operation}`,
+            });
+        }
+        // Broadcast editor update to all session participants
+        messageSender.broadcast({
+            type: "editor_update",
+            operation: operation,
+            content,
+            format: "markdown",
+            session_id: "", // Filled by the message sender
+        });
+        return Promise.resolve({
+            response: `Editor updated with ${operation} operation`,
+            overwriteResponse: "", // Don't clutter context with this response
+        });
     };
     return {
         // eslint-disable-next-line @typescript-eslint/require-await
         setup: async (agent) => {
-            agent.addAgentTool(OPEN_URL_DESC, toolFn);
+            agent.addAgentTool(EDIT_TEXT_DESC, toolFn);
         },
     };
 }
@@ -297,16 +104,20 @@ exports.testTool = {
 };
 /**
  * Add a set of agent tools for chat sessions.
+ *
+ * This includes all general-purpose tools plus chat-specific tools
+ * like image generation.
  */
-async function addDefaultChatTools(agent, timezone, fileManager, llmUrl, llmApiKey) {
-    await agent.addAgentToolProvider(datetimeTool(timezone));
-    await agent.addAgentToolProvider(exports.calculatorTool);
-    await agent.addAgentToolProvider(renderTool(fileManager));
-    await agent.addAgentToolProvider(webSearchTool());
-    await agent.addAgentToolProvider(openURLTool());
-    await agent.addAgentToolProvider((0, sessionFileManager_1.fileManagerTool)(fileManager));
-    await agent.addAgentToolProvider(await (0, imageGeneratorTools_1.genImageFileTool)(llmUrl, llmApiKey, fileManager));
-    if (DEVELOPMENT) {
+async function addDefaultChatTools(agent, timezone, platform, fileManager, messageSender) {
+    await agent.addAgentToolProvider((0, tools_1.datetimeTool)(timezone));
+    await agent.addAgentToolProvider(tools_1.calculatorTool);
+    await agent.addAgentToolProvider((0, tools_1.renderTool)(fileManager));
+    await agent.addAgentToolProvider((0, tools_1.webSearchTool)());
+    await agent.addAgentToolProvider((0, tools_1.openURLTool)());
+    await agent.addAgentToolProvider((0, tools_1.fileManagerTool)(fileManager));
+    await agent.addAgentToolProvider(await (0, imageGeneratorTools_1.genImageFileTool)(platform, fileManager));
+    await agent.addAgentToolProvider(editTextTool(messageSender));
+    if (DEVELOPMENT || TEST) {
         await agent.addAgentToolProvider(exports.testTool);
     }
 }

package/dist/agent/src/chat/utils/approvalManager.js

@@ -33,7 +33,7 @@ class ToolApprovalManager {
      *
      * The returned `requested` value indicates whether approval was requested.
      */
-    async getApproval(serverName, tool, toolCall) {
+    async getApproval(serverName, tool, toolCall, alt) {
         const autoApproved = (0, sdk_1.prefsGetAutoApprove)(this.agentProfilePreferences, serverName, tool);
         if (autoApproved) {
             return { approved: true, requested: false };
@@ -47,6 +47,7 @@ class ToolApprovalManager {
                 id,
                 tool_call: toolCall,
                 session_id: this.sessionUUID,
+                ...(alt ? { alt } : {}),
             });
             logger.debug(`[ApprovalManager.getApproval] awaiting approval ${id}`);
             const approval = await approvalP;
@@ -54,7 +55,7 @@ class ToolApprovalManager {
             // Handle any auto-approve update, informing other clients.
             if (approval.auto_approve) {
                 logger.debug("[ApprovalManager.getApproval] updated preferences");
-                const autoApprovalMsg = await this.setAutoApprove(serverName, tool, true);
+                const autoApprovalMsg = await this.setAutoApprove(serverName, tool, true, alt);
                 if (autoApprovalMsg) {
                     this.sender.broadcast(autoApprovalMsg);
                 }
@@ -65,6 +66,7 @@ class ToolApprovalManager {
                 id: approval.id,
                 result: approval.result,
                 session_id: this.sessionUUID,
+                ...(alt ? { alt } : {}),
             });
             return { approved: approval.result, requested: true };
         }
@@ -78,7 +80,7 @@ class ToolApprovalManager {
      * Handle a request to set auto-approval for a given tool.  If there was a
      * change, return the message to be broadcast.
      */
-    async setAutoApprove(serverName, tool, autoApprove) {
+    async setAutoApprove(serverName, tool, autoApprove, alt) {
         if ((0, sdk_1.prefsSetAutoApprove)(this.agentProfilePreferences, serverName, tool, autoApprove)) {
             await this.writer.updatePreferences(this.agentProfileUUID, this.agentProfilePreferences);
             return {
@@ -87,6 +89,7 @@ class ToolApprovalManager {
                 tool,
                 auto_approve: autoApprove,
                 session_id: this.sessionUUID,
+                ...(alt ? { alt } : {}),
             };
         }
     }

package/dist/agent/src/chat/utils/multiAsyncQueue.js

@@ -15,6 +15,9 @@ class MultiAsyncQueue {
     getMaxBacklog() {
         return this.maxBacklog;
     }
+    getEntries() {
+        return this.queue.slice();
+    }
     tryEnqueue(queueEntry) {
         if (this.maxBacklog > 0 && this.queue.length >= this.maxBacklog) {
             return false;