@xalia/agent 0.6.4 → 0.6.6

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

@@ -4,14 +4,14 @@ exports.Agent = exports.DEFAULT_LLM_URL = exports.AgentProfile = void 0;
 exports.createUserMessage = createUserMessage;
 exports.createUserMessageEnsure = createUserMessageEnsure;
 exports.completionToAssistantMessageParam = completionToAssistantMessageParam;
-const mcpServerManager_1 = require("./mcpServerManager");
 const assert_1 = require("assert");
-const sdk_1 = require("@xalia/xmcp/sdk");
-var sdk_2 = require("@xalia/xmcp/sdk");
-Object.defineProperty(exports, "AgentProfile", { enumerable: true, get: function () { return sdk_2.AgentProfile; } });
+var sdk_1 = require("@xalia/xmcp/sdk");
+Object.defineProperty(exports, "AgentProfile", { enumerable: true, get: function () { return sdk_1.AgentProfile; } });
+const sdk_2 = require("@xalia/xmcp/sdk");
+const mcpServerManager_1 = require("./mcpServerManager");
 exports.DEFAULT_LLM_URL = "http://localhost:5001/v1";
 const MAX_TOOL_CALL_RESPONSE_LENGTH = 4000;
-const logger = (0, sdk_1.getLogger)();
+const logger = (0, sdk_2.getLogger)();
 class Agent {
     constructor(eventHandler, mcpServerManager, llm, contextManager) {
         /// The full list of tools, ready to pass to the LLM
@@ -31,7 +31,7 @@ class Agent {
         return this.mcpServerManager.shutdown();
     }
     getAgentProfile() {
-        return new sdk_1.AgentProfile(this.llm.getModel(), this.getSystemPrompt(), this.mcpServerManager.getMcpServerSettings());
+        return new sdk_2.AgentProfile(this.llm.getModel(), this.getSystemPrompt(), this.mcpServerManager.getMcpServerSettings());
     }
     getConversation() {
         const llmMessages = this.contextManager.getLLMContext();
@@ -89,10 +89,11 @@ class Agent {
                     role: "tool",
                     tool_call_id: toolCall.id,
                     content: result.response,
+                    ...(result._meta ? { _meta: result._meta } : {}),
+                    ...(result.structuredContent
+                        ? { structuredContent: result.structuredContent }
+                        : {}),
                 };
-                if (result.metadata) {
-                    toolResult.metadata = result.metadata;
-                }
                 context.push(toolResult);
                 // If the tool call requested that its args be redacted, this can be
                 // done now - before the next LLM invocation.
@@ -207,7 +208,7 @@ class Agent {
     /**
      * Handle the details of getting approval (if required), invoking the tool
      * handler, informing the IAgentEventHandler of the result, and returns the
-     * OpenAI.ChatCompletionToolMessageParam to be used in the conversation.
+     * ChatCompletionToolMessageParam to be used in the conversation.
      */
     async doToolCall(toolCall) {
         // If the tool is and "agent" (internal) tool, we can just execute it.
@@ -237,7 +238,7 @@ class Agent {
                     result = { response: "User denied tool request." };
                 }
                 else {
-                    result = { response: await this.mcpServerManager.invoke(tc) };
+                    result = await this.mcpServerManager.invoke(tc);
                 }
                 logger.debug(`tool call result ${JSON.stringify(result)}`);
             }

package/dist/agent/src/agent/dummyLLM.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DummyLLM = void 0;
+// import { OpenAI } from "openai";
 const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const logger = (0, sdk_1.getLogger)();
@@ -47,25 +48,33 @@ class DummyLLM {
     getUrl() {
         return "";
     }
-    async getConversationResponse(messages, _tools, onMessage) {
+    async getConversationResponse(messages, _tools, onMessage, onReasoning) {
         await new Promise((r) => setTimeout(r, 0));
         (0, assert_1.strict)(this.idx < this.responses.length);
         this.lastRequest = messages;
-        const response = this.responses[this.idx++];
-        if (response.finish_reason === "error") {
-            throw new Error(response.message);
-        }
-        if (onMessage) {
-            const message = response.message;
-            void onMessage(message.content || "", true);
+        for (;;) {
+            const response = this.responses[this.idx++];
+            if (response.finish_reason === "error") {
+                throw new Error(response.message);
+            }
+            if (response.finish_reason === "reasoning") {
+                if (onReasoning) {
+                    await onReasoning(response.message);
+                }
+                continue;
+            }
+            if (onMessage) {
+                const message = response.message;
+                void onMessage(message.content || "", true);
+            }
+            return {
+                id: String(this.idx),
+                choices: [response],
+                created: Date.now(),
+                model: "dummyLlmModel",
+                object: "chat.completion",
+            };
         }
-        return {
-            id: String(this.idx),
-            choices: [response],
-            created: Date.now(),
-            model: "dummyLlmModel",
-            object: "chat.completion",
-        };
     }
     setModel(_model) {
         (0, assert_1.strict)(false, "unexpected call to setModel");

package/dist/agent/src/agent/llm.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XALIA_APP_HEADER = void 0;
-exports.choiceDeltaExtractReasoning = choiceDeltaExtractReasoning;
 exports.XALIA_APP_HEADER = {
     "HTTP-Referer": "xalia.ai",
     "X-Title": "Xalia",
 };
-function choiceDeltaExtractReasoning(delta) {
-    if (delta.reasoning) {
-        return delta.reasoning;
-    }
-    if (delta.reasoning_details) {
-        let reasoning = "";
-        for (const details of delta.reasoning_details) {
-            if (details.type !== "reasoning.text") {
-                throw new Error(`unexpected details.type: ${details.type}`);
-            }
-            if (details.text) {
-                if (typeof details.text !== "string") {
-                    throw new Error(`unexpected typeof details.text: ${typeof details.text}`);
-                }
-                reasoning += details.text;
-            }
-        }
-        return reasoning;
-    }
-    return undefined;
-}

package/dist/agent/src/agent/mcpServerManager.js

@@ -1,38 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpServerManager = exports.McpServerInfoRW = exports.McpServerInfo = void 0;
+exports.isMcpServerToolCallMetaData = isMcpServerToolCallMetaData;
 exports.computeQualifiedName = computeQualifiedName;
 exports.splitQualifiedName = splitQualifiedName;
 exports.computeOpenAIToolList = computeOpenAIToolList;
 exports.mcpToolToOpenAITool = mcpToolToOpenAITool;
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const sdk_1 = require("@xalia/xmcp/sdk");
 const tokenAuth_1 = require("./tokenAuth");
 const assert_1 = require("assert");
-const sdk_1 = require("@xalia/xmcp/sdk");
 const logger = (0, sdk_1.getLogger)();
+const mcpServerToolCallMetaKeys = [
+    "xalia/mcpServerName",
+];
+function isMcpServerToolCallMetaData(meta) {
+    return (!!meta &&
+        typeof meta === "object" &&
+        mcpServerToolCallMetaKeys.every((k) => k in meta));
+}
 /**
  * The (read-only) McpServerInfo to expose to external classes.  Callers
  * should not modify this data directly.  Only through the McpServerManager
  * class.
  */
 class McpServerInfo {
-    constructor(tools) {
+    constructor(name, tools, resources) {
         const toolsMap = {};
         for (const mcpTool of tools) {
             const toolName = mcpTool.name;
             toolsMap[toolName] = mcpTool;
         }
+        this.name = name;
         this.tools = tools;
+        this.resources = resources;
         this.toolsMap = toolsMap;
         this.enabledToolsMap = new Map();
     }
+    getName() {
+        return this.name;
+    }
     getEnabledTools() {
         return this.enabledToolsMap;
     }
     getTools() {
         return this.tools;
     }
+    getResources() {
+        return this.resources;
+    }
     getTool(toolName) {
         return this.toolsMap[toolName];
     }
@@ -57,8 +75,9 @@ exports.McpServerInfoRW = McpServerInfoRW;
  * McpServerManager.
  */
 class McpServerInfoInternal extends McpServerInfoRW {
-    constructor(client, tools) {
-        super(tools);
+    constructor(name, client, tools, resources) {
+        super(name, tools, resources);
+        logger.debug(`[McpServerInfoInternal] tools: ${JSON.stringify(tools)}`);
         const callbacks = new Map();
         for (const mcpTool of tools) {
             const toolName = mcpTool.name;
@@ -80,7 +99,17 @@ class McpServerInfoInternal extends McpServerInfoRW {
                 (0, assert_1.strict)(typeof content0 === "object");
                 const content0Text = content0.text;
                 (0, assert_1.strict)(typeof content0Text === "string");
-                return content0Text;
+                const meta = (toolResult._meta ||
+                    {});
+                meta["xalia/mcpServerName"] = this.getName();
+                (0, assert_1.strict)(isMcpServerToolCallMetaData(meta));
+                return {
+                    response: content0Text,
+                    _meta: meta,
+                    ...(toolResult.structuredContent
+                        ? { structuredContent: toolResult.structuredContent }
+                        : {}),
+                };
             };
             callbacks.set(toolName, callback);
         }
@@ -93,6 +122,13 @@ class McpServerInfoInternal extends McpServerInfoRW {
     getCallback(toolName) {
         return this.callbacks.get(toolName);
     }
+    async readResource(uri) {
+        const res = await this.client.readResource({
+            uri,
+        });
+        logger.info(`readResource: got: ${JSON.stringify(res)}`);
+        return res.contents;
+    }
 }
 /**
  * Manage a set of MCP servers, where the tools for each server have an
@@ -121,14 +157,7 @@ class McpServerManager {
     getMcpServer(mcpServerName) {
         return this.getMcpServerInternal(mcpServerName);
     }
-    async addMcpServerWithSSEUrl(mcpServerName, url, apiKey, tools) {
-        logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
-        const sseTransportOptions = {};
-        if (apiKey) {
-            sseTransportOptions.authProvider = new tokenAuth_1.TokenAuth(apiKey);
-        }
-        const urlO = new URL(url);
-        const transport = new sse_js_1.SSEClientTransport(urlO, sseTransportOptions);
+    async addMcpServerWithTransport(mcpServerName, transport, tools) {
         const client = new index_js_1.Client({
             name: "@xalia/agent",
             version: "1.0.0",
@@ -144,17 +173,42 @@ class McpServerManager {
         }
         await this.addMcpServerWithClient(client, mcpServerName, tools);
     }
+    async addMcpServerWithSSEUrl(mcpServerName, url, apiKey, tools) {
+        logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
+        const sseTransportOptions = {};
+        if (apiKey) {
+            sseTransportOptions.authProvider = new tokenAuth_1.TokenAuth(apiKey);
+        }
+        const urlO = new URL(url);
+        const transport = new sse_js_1.SSEClientTransport(urlO, sseTransportOptions);
+        return this.addMcpServerWithTransport(mcpServerName, transport, tools);
+    }
+    async addMcpServerWithStreamableHTTPUrl(mcpServerName, url, apiKey) {
+        logger.debug(`Adding mcp (s-http) server ${mcpServerName}: ${url}`);
+        const transportOptions = {};
+        if (apiKey) {
+            transportOptions.authProvider = new tokenAuth_1.TokenAuth(apiKey);
+        }
+        const urlO = new URL(url);
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(urlO, transportOptions);
+        return this.addMcpServerWithTransport(mcpServerName, transport);
+    }
     /**
      * Add MCP server from an already connected McpClient.
      */
     async addMcpServerWithClient(client, mcpServerName, tools) {
         try {
-            // TODO; require the tools to be passed in.
+            // TODO: require the tools to be passed in.
+            const resourcesP = client.listResources().catch((err) => {
+                logger.warn(`resources ${mcpServerName}: ${JSON.stringify(err)} ${String(err)}`);
+                return { resources: [] };
+            });
             if (!tools) {
                 const mcpTools = await client.listTools();
                 tools = mcpTools.tools;
             }
-            this.mcpServers.set(mcpServerName, new McpServerInfoInternal(client, tools));
+            const resources = (await resourcesP).resources;
+            this.mcpServers.set(mcpServerName, new McpServerInfoInternal(mcpServerName, client, tools, resources));
         }
         catch (e) {
             await client.close();
@@ -231,6 +285,10 @@ class McpServerManager {
         }
         return cb(JSON.stringify(toolCall.args));
     }
+    async getResource(serverName, uri) {
+        const server = this.getMcpServerInternal(serverName);
+        return server.readResource(uri);
+    }
     /**
      * "Settings" refers to the set of added servers and enabled tools.
      */

package/dist/agent/src/agent/openAI.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.choiceDeltaExtractReasoning = choiceDeltaExtractReasoning;
+// /**
+//  * A chat completion message with extra reasoning tokens.
+//  */
+// export interface ChatCompletionMessageWithReasoning
+//   extends OpenAI.Chat.Completions.ChatCompletionMessage {
+//   reasoning?: string;
+// }
+// Util function to extract reasoning tokens
+function choiceDeltaExtractReasoning(delta) {
+    if (delta.reasoning) {
+        return delta.reasoning;
+    }
+    if (delta.reasoning_details) {
+        let reasoning = "";
+        for (const details of delta.reasoning_details) {
+            if (details.type !== "reasoning.text") {
+                throw new Error(`unexpected details.type: ${details.type}`);
+            }
+            if (details.text) {
+                if (typeof details.text !== "string") {
+                    throw new Error(`unexpected typeof details.text: ${typeof details.text}`);
+                }
+                reasoning += details.text;
+            }
+        }
+        return reasoning;
+    }
+    return undefined;
+}

package/dist/agent/src/agent/openAILLM.js

@@ -1,8 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAILLM = void 0;
+const assert_1 = require("assert");
 const llm_1 = require("./llm");
 const openai_1 = require("openai");
+function toolCallFromOpenAi(toolCall) {
+    (0, assert_1.strict)(toolCall.type === "function");
+    return toolCall;
+}
+function messageFromOpenAi(message) {
+    return {
+        ...message,
+        tool_calls: message.tool_calls?.map(toolCallFromOpenAi),
+    };
+}
+function choicesFromOpenAI(choice) {
+    return {
+        ...choice,
+        message: messageFromOpenAi(choice.message),
+        // tool_calls: choice.tool_calls?.map(toolCallFromOpenAi),
+    };
+}
+function completionFromOpenAI(completion) {
+    return {
+        ...completion,
+        choices: completion.choices.map(choicesFromOpenAI),
+    };
+}
 class OpenAILLM {
     constructor(apiKey, apiUrl, model) {
         this.openai = new openai_1.OpenAI({
@@ -34,7 +58,7 @@ class OpenAILLM {
                 await onMessage(message.content, true);
             }
         }
-        return completion;
+        return completionFromOpenAI(completion);
     }
 }
 exports.OpenAILLM = OpenAILLM;

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

@@ -7,6 +7,7 @@ const openai_1 = require("openai");
 const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const llm_1 = require("./llm");
+const openAI_1 = require("./openAI");
 const logger = (0, sdk_1.getLogger)();
 function initialToolCallFunction(deltaFn) {
     //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
@@ -25,7 +26,8 @@ function initialToolCallFunction(deltaFn) {
         name: deltaFn?.name || "",
     };
 }
-function updateToolCallFunction(existingFn, deltaFn // eslint-disable-line
+function updateToolCallFunction(existingFn, // eslint-disable-line
+deltaFn // eslint-disable-line
 ) {
     //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
     //     arguments?: string;
@@ -221,7 +223,7 @@ function updateCompletionMessage(message, delta) {
             message.tool_calls = updateToolCalls(message.tool_calls, t);
         }
     }
-    const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+    const reasoning = (0, openAI_1.choiceDeltaExtractReasoning)(delta);
     if (reasoning) {
         updateReasoning(message, reasoning);
     }
@@ -355,6 +357,7 @@ function initializeCompletion(chunk) {
             model: chunk.model,
             object: "chat.completion",
             service_tier: chunk.service_tier,
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             system_fingerprint: chunk.system_fingerprint,
             usage: chunk.usage ?? undefined,
         },
@@ -388,7 +391,9 @@ function updateCompletion(completion, chunk) {
     (0, assert_1.strict)(completion.id === chunk.id);
     (0, assert_1.strict)(completion.model === chunk.model);
     completion.service_tier = completion.service_tier || chunk.service_tier;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     completion.system_fingerprint =
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
         completion.system_fingerprint || chunk.system_fingerprint;
     completion.usage = completion.usage || chunk.usage || undefined;
     return updateCompletionChoices(completion.choices, chunk.choices);
@@ -460,7 +465,7 @@ class OpenAILLMStreaming {
             if (onReasoning) {
                 const delta = chunk.choices[0]
                     ?.delta;
-                const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+                const reasoning = (0, openAI_1.choiceDeltaExtractReasoning)(delta);
                 if (reasoning) {
                     await onReasoning(reasoning);
                 }

package/dist/agent/src/agent/sudoMcpServerManager.js

@@ -4,6 +4,8 @@ exports.SkillManager = exports.LOCAL_SERVER_URL = void 0;
 const mcpServerManager_1 = require("./mcpServerManager");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const DEVELOPMENT = process.env.DEVELOPMENT === "1";
+const DEV_MCP_SERVER_URL = process.env.DEV_MCP_SERVER_URL || "http://localhost:8000/mcp";
 const logger = (0, sdk_1.getLogger)();
 exports.LOCAL_SERVER_URL = "http://localhost:5001";
 /**
@@ -47,6 +49,10 @@ class SkillManager extends mcpServerManager_1.McpServerManager {
         const apiClient = new sdk_1.ApiClient(sudoMcpUrl ?? sdk_1.DEFAULT_SERVER_URL, sudoMcpApiKey ?? "dummy_key");
         // Fetch server list
         const servers = await apiClient.listServers();
+        if (DEVELOPMENT) {
+            servers.push(new sdk_1.McpServerBrief("local_dev", "Local Dev Server", "A local mcp server using streamable-HTTP for development use.  " +
+                `URL: ${DEV_MCP_SERVER_URL}`, false, {}, "", null, null, DEV_MCP_SERVER_URL));
+        }
         const [mcpServers, mcpServersMap] = buildServersList(servers);
         return new SkillManager(apiClient, mcpServers, mcpServersMap, new Map(), openUrl, authorized_url);
     }
@@ -126,15 +132,22 @@ class SkillManager extends mcpServerManager_1.McpServerManager {
      * transport. Validates the server's config schema, if applicable.
      */
     async addMcpServer(serverName, enableAll) {
-        const tools = await this.getServerTools(serverName);
-        const originalName = this.serverBriefsMap[serverName].originalName;
-        const mcpserver = await this.apiClient.getDetails(originalName, "run");
-        const client = new index_js_1.Client({
-            name: "@xalia/agent",
-            version: "1.0.0",
-        });
-        await connectServer(client, this.apiClient, mcpserver, this.openUrl, this.authorized_url);
-        await this.addMcpServerWithClient(client, serverName, tools);
+        const brief = this.serverBriefsMap[serverName];
+        if (brief.url_override) {
+            // Assume no api key for now
+            await this.addMcpServerWithStreamableHTTPUrl(serverName, brief.url_override);
+        }
+        else {
+            const tools = await this.getServerTools(serverName);
+            const originalName = this.serverBriefsMap[serverName].originalName;
+            const mcpserver = await this.apiClient.getDetails(originalName, "run");
+            const client = new index_js_1.Client({
+                name: "@xalia/agent",
+                version: "1.0.0",
+            });
+            await connectServer(client, this.apiClient, mcpserver, this.openUrl, this.authorized_url);
+            await this.addMcpServerWithClient(client, serverName, tools);
+        }
         if (enableAll) {
             this.enableAllTools(serverName);
         }

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

@@ -366,7 +366,7 @@ class ChatClient {
      * @param templateName - the template name
      * @param teamUuid - the team uuid
      */
-    createNewAgent(agentName, templateName, teamUuid) {
+    createNewAgent(agentName, templateName, teamUuid, model) {
         if (this.closed) {
             throw new Error("ChatClient is closed");
         }
@@ -376,6 +376,7 @@ class ChatClient {
                 title: agentName,
                 template_name: templateName,
                 team_uuid: teamUuid,
+                model,
             });
         }
         catch (error) {

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

@@ -91,10 +91,10 @@ class RemoteSudoMcpServerManager {
             tool: toolName,
         });
     }
-    onMcpServerAdded(mcpServerName, tools, enabled_tools) {
+    onMcpServerAdded(mcpServerName, tools, enabled_tools, resources) {
         logger.debug(`[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
             `, enabled: ${JSON.stringify(enabled_tools)}`);
-        const mcpServerInfo = new mcpServerManager_1.McpServerInfoRW(tools);
+        const mcpServerInfo = new mcpServerManager_1.McpServerInfoRW(mcpServerName, tools, resources);
         for (const tool of enabled_tools) {
             mcpServerInfo.enableTool(tool);
         }
@@ -205,6 +205,29 @@ class SessionClient {
             paused,
         });
     }
+    addMcpServerFromUrl(server_name, url) {
+        this.sendSessionMessage({
+            type: "add_mcp_server_from_url",
+            server_name,
+            url,
+        });
+    }
+    async getMcpResource(server_name, uri) {
+        const client_message_id = (0, uuid_1.v4)();
+        const resourceP = this.responseHandler.waitForResponse(client_message_id);
+        this.sender.send({
+            type: "get_mcp_resource",
+            session_id: this.sessionUUID,
+            client_message_id,
+            server_name,
+            uri,
+        });
+        const resourceMsg = await resourceP;
+        if (resourceMsg.type !== "mcp_resource") {
+            throw new Error(`unexpected response to resource req: ${JSON.stringify(resourceMsg)}`);
+        }
+        return resourceMsg.contents;
+    }
     userMessage(msg, imageB64) {
         (0, assert_1.strict)(msg || imageB64, "Either message or image must be provided");
         this.sendSessionMessage({ type: "msg", message: msg, imageB64 });
@@ -313,7 +336,7 @@ class SessionClient {
             // State updates
             //
             case "mcp_server_added":
-                this.smsm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools);
+                this.smsm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools, message.resources);
                 break;
             case "mcp_server_removed":
                 this.smsm.onMcpServerRemoved(message.server_name);
@@ -344,6 +367,8 @@ class SessionClient {
             case "user_removed":
                 this.participants.delete(message.user_uuid);
                 break;
+            // Responses to requests which can be awaited
+            case "mcp_resource":
             case "session_shared":
                 this.responseHandler.onMessage(message);
                 break;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXTENSION_TO_SESSION_FILE_MIME_TYPE = exports.SESSION_FILE_TEXT_MIME_TYPES = exports.SESSION_FILE_MIME_TYPES = void 0;
 exports.isSessionFileMimeType = isSessionFileMimeType;
 exports.isSessionFileTextMimeType = isSessionFileTextMimeType;
+exports.isFileMetaData = isFileMetaData;
 exports.getSessionFileMimeTypeFromDataUrl = getSessionFileMimeTypeFromDataUrl;
 exports.createSessionFileDataUrl = createSessionFileDataUrl;
 const mimeTypes_1 = require("./mimeTypes");
@@ -10,6 +11,7 @@ exports.SESSION_FILE_MIME_TYPES = [
     ...mimeTypes_1.IMAGE_MIME_TYPES,
     "text/plain",
     "text/markdown",
+    "text/html",
     "application/pdf",
     "image/svg+xml",
 ];
@@ -32,6 +34,14 @@ exports.EXTENSION_TO_SESSION_FILE_MIME_TYPE = {
     txt: "text/plain",
     md: "text/markdown",
 };
+// Checks that the array of keys matches FileMetaData
+const fileMetaKeys = [
+    "xalia/fileUri",
+    "xalia/fileMimeType",
+];
+function isFileMetaData(meta) {
+    return (!!meta && typeof meta === "object" && fileMetaKeys.every((k) => k in meta));
+}
 function getSessionFileMimeTypeFromDataUrl(data_url) {
     const mimeType = (0, mimeTypes_1.getMimeTypeFromDataUrl)(data_url);
     if (!isSessionFileMimeType(mimeType)) {

package/dist/agent/src/chat/protocol/messages.js

@@ -95,6 +95,7 @@ function isServerSessionScopedMessage(message) {
         case "approve_tool_call":
         case "render_html":
         case "session_shared":
+        case "mcp_resource":
             return true;
         default: {
             const _ = msg;

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

@@ -55,9 +55,9 @@ class ChatContextManager {
     // IContextManager.getLLMContext
     getLLMContext() {
         if (this.fileManagerDescriptionsDirty) {
-            const filesSummary = (0, sessionFileManager_1.listFilesForLLM)(this.fileManager);
-            logger.debug(`[ChatContextManager] filemanager summary:\n${filesSummary}`);
-            this.llmContext.setPromptFragment("file_manager", filesSummary);
+            const prompt = (0, sessionFileManager_1.createSessionFilesManagerPrompt)(this.fileManager);
+            logger.debug(`[ChatContextManager] filemanager prompt:\n${prompt}`);
+            this.llmContext.setPromptFragment("file_manager", prompt);
             this.fileManagerDescriptionsDirty = false;
         }
         return this.llmContext.getLLMContext();
@@ -150,7 +150,7 @@ class ChatContextManager {
         // Compute the new llm messages
         const llmUserMessages = [];
         for (const msg of pendingUserMessages) {
-            const userMsg = (0, agent_1.createUserMessage)(msg.message, msg.imageB64, msg.user_nickname);
+            const userMsg = (0, agent_1.createUserMessage)(msg.message, msg.imageB64, msg.user_uuid);
             if (userMsg) {
                 llmUserMessages.push(userMsg);
             }

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

@@ -193,7 +193,7 @@ function chatToolResultMessageToSessionMessage(chatMessage) {
     };
 }
 function chatUserMessageToSessionMessage(chatMessage) {
-    const userMsg = (0, agent_1.createUserMessage)(chatMessage.message, chatMessage.imageB64, chatMessage.user_nickname);
+    const userMsg = (0, agent_1.createUserMessage)(chatMessage.message, chatMessage.imageB64, chatMessage.user_uuid);
     (0, assert_1.strict)(userMsg);
     return {
         message_idx: chatMessage.message_idx,