@xalia/agent 0.5.7 → 0.6.0

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

@@ -25,7 +25,7 @@ class McpServerInfo {
         }
         this.tools = tools;
         this.toolsMap = toolsMap;
-        this.enabledToolsMap = {};
+        this.enabledToolsMap = new Map();
     }
     getEnabledTools() {
         return this.enabledToolsMap;
@@ -44,10 +44,10 @@ exports.McpServerInfo = McpServerInfo;
  */
 class McpServerInfoRW extends McpServerInfo {
     enableTool(toolName) {
-        this.enabledToolsMap[toolName] = true;
+        this.enabledToolsMap.set(toolName, true);
     }
     disableTool(toolName) {
-        delete this.enabledToolsMap[toolName];
+        this.enabledToolsMap.delete(toolName);
     }
 }
 exports.McpServerInfoRW = McpServerInfoRW;
@@ -59,13 +59,13 @@ exports.McpServerInfoRW = McpServerInfoRW;
 class McpServerInfoInternal extends McpServerInfoRW {
     constructor(client, tools) {
         super(tools);
-        const callbacks = {};
+        const callbacks = new Map();
         for (const mcpTool of tools) {
             const toolName = mcpTool.name;
             // Create callback
             const callback = async (argStr) => {
                 logger.debug(`cb for ${toolName} invoked with args (${typeof argStr}): ` +
-                    `${JSON.stringify(argStr)}`);
+                    JSON.stringify(argStr));
                 const argsObj = JSON.parse(argStr);
                 const toolResult = await client.callTool({
                     name: toolName,
@@ -82,7 +82,7 @@ class McpServerInfoInternal extends McpServerInfoRW {
                 (0, assert_1.strict)(typeof content0Text === "string");
                 return content0Text;
             };
-            callbacks[toolName] = callback;
+            callbacks.set(toolName, callback);
         }
         this.client = client;
         this.callbacks = callbacks;
@@ -91,7 +91,7 @@ class McpServerInfoInternal extends McpServerInfoRW {
         await this.client.close();
     }
     getCallback(toolName) {
-        return this.callbacks[toolName];
+        return this.callbacks.get(toolName);
     }
 }
 /**
@@ -101,27 +101,27 @@ class McpServerInfoInternal extends McpServerInfoRW {
  */
 class McpServerManager {
     constructor() {
-        this.mcpServers = {};
+        this.mcpServers = new Map();
         this.enabledToolsDirty = true;
         this.enabledOpenAITools = [];
     }
     async shutdown() {
-        await Promise.all(Object.keys(this.mcpServers).map((name) => {
+        await Promise.all(Array.from(this.mcpServers.entries()).map(([name, server]) => {
             logger.debug(`shutting down: ${name}...`);
-            this.mcpServers[name].shutdown();
+            return server.shutdown();
         }));
-        this.mcpServers = {};
+        this.mcpServers.clear();
     }
     hasMcpServer(mcpServerName) {
-        return !!this.mcpServers[mcpServerName];
+        return this.mcpServers.has(mcpServerName);
     }
     getMcpServerNames() {
-        return Object.keys(this.mcpServers);
+        return Array.from(this.mcpServers.keys());
     }
     getMcpServer(mcpServerName) {
         return this.getMcpServerInternal(mcpServerName);
     }
-    async addMcpServer(mcpServerName, url, apiKey, tools) {
+    async addMcpServerWithSSEUrl(mcpServerName, url, apiKey, tools) {
         logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
         const sseTransportOptions = {};
         if (apiKey) {
@@ -154,7 +154,7 @@ class McpServerManager {
                 const mcpTools = await client.listTools();
                 tools = mcpTools.tools;
             }
-            this.mcpServers[mcpServerName] = new McpServerInfoInternal(client, tools);
+            this.mcpServers.set(mcpServerName, new McpServerInfoInternal(client, tools));
         }
         catch (e) {
             await client.close();
@@ -163,7 +163,7 @@ class McpServerManager {
     }
     async removeMcpServer(mcpServerName) {
         const server = this.getMcpServerInternal(mcpServerName);
-        delete this.mcpServers[mcpServerName];
+        this.mcpServers.delete(mcpServerName);
         await server.shutdown();
         this.enabledToolsDirty = true;
     }
@@ -215,7 +215,7 @@ class McpServerManager {
         const server = this.getMcpServerInternal(mcpServerName);
         const cb = server.getCallback(toolName);
         if (!cb) {
-            throw `Unknown tool ${qualifiedToolName}`;
+            throw new Error(`Unknown tool ${qualifiedToolName}`);
         }
         return cb(JSON.stringify(args));
     }
@@ -230,8 +230,8 @@ class McpServerManager {
         //
         // may be interpreted as "all tools for <server>".  If the client has left
         // a server with no tools enabled, we mark it as disabled.
-        for (const [serverName, server] of Object.entries(this.mcpServers)) {
-            const tools = Object.keys(server.getEnabledTools());
+        for (const [serverName, server] of this.mcpServers) {
+            const tools = Array.from(server.getEnabledTools().keys());
             if (tools.length > 0) {
                 config[serverName] = tools;
             }
@@ -239,11 +239,11 @@ class McpServerManager {
         return config;
     }
     getMcpServerInternal(mcpServerName) {
-        const server = this.mcpServers[mcpServerName];
+        const server = this.mcpServers.get(mcpServerName);
         if (server) {
             return server;
         }
-        throw Error(`unknown server ${mcpServerName}`);
+        throw Error(`[getMcpServerInternal] unknown server ${mcpServerName}`);
     }
 }
 exports.McpServerManager = McpServerManager;
@@ -262,13 +262,12 @@ function splitQualifiedName(qualifiedToolName) {
 }
 function computeOpenAIToolList(mcpServers) {
     const openaiTools = [];
-    for (const mcpServerName in mcpServers) {
-        const mcpServer = mcpServers[mcpServerName];
+    for (const [mcpServerName, mcpServer] of mcpServers) {
         const tools = mcpServer.getTools();
         const enabled = mcpServer.getEnabledTools();
         for (const mcpTool of tools) {
             const toolName = mcpTool.name;
-            if (enabled[toolName]) {
+            if (enabled.get(toolName)) {
                 const qualifiedName = computeQualifiedName(mcpServerName, toolName);
                 const openaiTool = mcpToolToOpenAITool(mcpTool, qualifiedName);
                 openaiTools.push(openaiTool);

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NULL_AGENT_EVENT_HANDLER = void 0;
+/**
+ * Trivial IAgentEventHandler implementation which does not track any messages
+ * and does not allow tool calls.
+ */
+exports.NULL_AGENT_EVENT_HANDLER = {
+    onCompletion: () => { },
+    onToolCallResult: () => { },
+    onAgentMessage: () => {
+        return new Promise((r) => {
+            r();
+        });
+    },
+    onToolCall: () => {
+        return new Promise((r) => {
+            r(false);
+        });
+    },
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NULL_PLATFORM = void 0;
+exports.NULL_PLATFORM = {
+    openUrl: () => {
+        throw new Error("null_platform openUrl called");
+    },
+    load: () => {
+        throw new Error("null_platform load called");
+    },
+    renderHTML: () => {
+        throw new Error("null_platform renderHTML called");
+    },
+};

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

@@ -39,9 +39,6 @@ function updateToolCallFunction(existingFn, deltaFn // eslint-disable-line
     // The function can have either (or possibly both) field(s) empty.
     // `arguments` has been observered to arrive in chunks.  The same is
     // probably true of `name`.
-    if (!deltaFn) {
-        return;
-    }
     if (deltaFn.name) {
         existingFn.name += deltaFn.name;
     }
@@ -107,8 +104,8 @@ function updateToolCalls(toolCalls, deltaToolCall // eslint-disable-line
     if (typeof toolCalls === "undefined") {
         toolCalls = [];
     }
-    const existing = toolCalls[deltaToolCall.index];
-    if (!existing) {
+    if (deltaToolCall.index >= toolCalls.length ||
+        !toolCalls[deltaToolCall.index]) {
         toolCalls[deltaToolCall.index] = initialToolCall(deltaToolCall);
     }
     else {
@@ -118,6 +115,7 @@ function updateToolCalls(toolCalls, deltaToolCall // eslint-disable-line
 }
 function initializeCompletionMessage(delta) {
     (0, assert_1.strict)(delta.role === undefined || delta.role == "assistant");
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     (0, assert_1.strict)(!delta.function_call);
     //   export interface ChatCompletionChunk.Choice.Delta {
     //     content?: string | null;
@@ -155,7 +153,9 @@ function initializeCompletionMessage(delta) {
     };
 }
 function updateCompletionMessage(message, delta) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     (0, assert_1.strict)(message.role === "assistant");
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     (0, assert_1.strict)(!message.function_call);
     (0, assert_1.strict)(!message.audio);
     (0, assert_1.strict)(message.tool_calls instanceof Array ||
@@ -187,6 +187,7 @@ function updateCompletionMessage(message, delta) {
             message.content = delta.content;
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     (0, assert_1.strict)(!delta.function_call);
     if (delta.refusal) {
         if (message.refusal) {
@@ -255,7 +256,9 @@ function updateCompletionChoice(completionChoice, chunkChoice) {
     (0, assert_1.strict)(completionChoice.index === chunkChoice.index);
     updateCompletionMessage(completionChoice.message, chunkChoice.delta);
     if (chunkChoice.finish_reason) {
-        (0, assert_1.strict)(completionChoice.finish_reason === null, `finish_reason already set: (${completionChoice.finish_reason})`);
+        (0, assert_1.strict)(
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        completionChoice.finish_reason === null, `finish_reason already set: (${completionChoice.finish_reason})`);
         completionChoice.finish_reason = chunkChoice.finish_reason;
         return true;
     }
@@ -263,9 +266,10 @@ function updateCompletionChoice(completionChoice, chunkChoice) {
 }
 function initializeCompletionChoices(chunkChoices) {
     // Technically, one choice could be done and the other still have some
-    // content to stream.  We keep it simple for now and assume only single
-    // choices, which allows us to mark everything as done if any choice we hit is
-    // done.
+    // content to stream.  We keep it simple for now and allow zero or one
+    // choice per chunk, which allows us to mark everything as done if any
+    // choice we hit is done. Zero choices can occur in usage-only chunks at
+    // the end of the stream.
     (0, assert_1.strict)(chunkChoices.length < 2);
     let msgDone = false;
     const choices = [];
@@ -280,10 +284,11 @@ function initializeCompletionChoices(chunkChoices) {
 }
 function updateCompletionChoices(completionChoices, chunkChoices) {
     // Technically, one choice could be done and the other still have some
-    // content to stream.  We keep it simple for now and assume only single
-    // choices, which allows us to mark everything as done if any choice we hit is
-    // done.
-    (0, assert_1.strict)(chunkChoices.length === 1);
+    // content to stream.  We keep it simple for now and allow zero or one
+    // choice per chunk, which allows us to mark everything as done if any
+    // choice we hit is done. Zero choices can occur in usage-only chunks at
+    // the end of the stream.
+    (0, assert_1.strict)(chunkChoices.length < 2);
     (0, assert_1.strict)(completionChoices.length === 1);
     let msgDone = false;
     for (const chunkChoice of chunkChoices) {
@@ -391,14 +396,18 @@ class OpenAILLMStreaming {
             messages,
             tools,
             stream: true,
+            stream_options: {
+                include_usage: true,
+            },
         });
         // Check the type casting above
         if (!chunks.iterator) {
-            throw "not a stream";
+            throw new Error("not a stream");
         }
         let aggregatedMessage;
         for await (const chunk of chunks) {
             logger.debug(`[stream] chunk: ${JSON.stringify(chunk)}`);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             if (chunk.object !== "chat.completion.chunk") {
                 // logger.warn("[stream]: unexpected message");
                 continue;
@@ -413,7 +422,10 @@ class OpenAILLMStreaming {
             }
             if (onMessage) {
                 // Inform the call of a message fragment if it contains any text.
+                // Note: chunks may have zero choices (e.g., usage-only chunks), so
+                // we safely access the first choice.
                 const delta = chunk.choices[0]?.delta;
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                 if (delta?.content) {
                     await onMessage(delta.content, false);
                 }

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemPromptProvider = void 0;
+const assert_1 = require("assert");
+/**
+ * Manage a structured system-prompt, built up of several components which can
+ * be updated at different frequencies.
+ */
+class SystemPromptProvider {
+    constructor(agentPrompt) {
+        this.agentPrompt = agentPrompt;
+        this.fragments = new Map();
+        this.fullPrompt = "";
+        this.updatePrompt = true;
+    }
+    /**
+     * This is not expected to change dynamically, but to be set exactly once at
+     * startup.  Thus existing prompts are not recomputed if this is updated.
+     */
+    static setGlobalPrompt(globalPrompt) {
+        SystemPromptProvider.globalPrompt = globalPrompt || "";
+    }
+    getAgentPrompt() {
+        return this.agentPrompt;
+    }
+    setAgentPrompt(agentPrompt) {
+        this.agentPrompt = agentPrompt;
+        this.updatePrompt = true;
+    }
+    setFragment(fragmentID, prompt) {
+        this.fragments.set(fragmentID, prompt);
+        this.updatePrompt = true;
+    }
+    removeFragment(fragmentID) {
+        this.fragments.delete(fragmentID);
+        this.updatePrompt = true;
+    }
+    getSystemPrompt() {
+        if (this.updatePrompt) {
+            this.computePrompt();
+        }
+        (0, assert_1.strict)(!this.updatePrompt);
+        return this.fullPrompt;
+    }
+    computePrompt() {
+        const global = SystemPromptProvider.globalPrompt.trimEnd();
+        const globalPost = global.length > 0 ? "\n" : "";
+        let prompt = SystemPromptProvider.globalPrompt.trimEnd() +
+            globalPost +
+            this.agentPrompt.trimEnd();
+        // TODO: allow some control over the ordering?
+        for (const v of this.fragments.values()) {
+            prompt += "\n" + v.trimEnd();
+        }
+        this.fullPrompt = prompt;
+        this.updatePrompt = false;
+    }
+}
+exports.SystemPromptProvider = SystemPromptProvider;
+/**
+ * A global prompt, common to all agents.
+ */
+SystemPromptProvider.globalPrompt = "";

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

@@ -10,11 +10,11 @@ class RepeatLLM {
         return "repeat";
     }
     getUrl() {
-        throw "cannot get url for RepeatLLM";
+        throw new Error("cannot get url for RepeatLLM");
     }
     async getConversationResponse(_messages, _tools, onMessage) {
-        await new Promise((r) => setTimeout(r, 0));
-        const content = `Message number ${this.idx++}`;
+        await new Promise((r) => setTimeout(r, 1000));
+        const content = `Message number ${String(this.idx++)}`;
         const response = {
             finish_reason: "stop",
             index: 0,
@@ -26,10 +26,10 @@ class RepeatLLM {
             },
         };
         if (onMessage) {
-            onMessage(content, true);
+            void onMessage(content, true);
         }
         return {
-            id: "" + this.idx,
+            id: String(this.idx),
             choices: [response],
             created: Date.now(),
             model: "dummyLlmModel",

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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 logger = (0, sdk_1.getLogger)();
@@ -25,11 +26,11 @@ class SanitizedServerBrief extends sdk_1.McpServerBrief {
  * Manages access to the catalogue of servers hosted by sudomcp.  Supports
  * adding these servers to McpServerManager.
  */
-class SkillManager {
-    constructor(mcpServerManager, apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
+class SkillManager extends mcpServerManager_1.McpServerManager {
+    constructor(apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
     // Redirect to this page after successful authorization
     authorized_url) {
-        this.mcpServerManager = mcpServerManager;
+        super();
         this.apiClient = apiClient;
         this.serverBriefs = serverBriefs;
         this.serverBriefsMap = serverBriefsMap;
@@ -41,18 +42,21 @@ class SkillManager {
      * Initialize an ApiClient to interface with SudoMCP backend and
      * fetch the current list of ServerBriefs.
      */
-    static async initialize(mcpServerManager, openUrl, sudoMcpUrl, sudoMcpApiKey, authorized_url) {
+    static async initialize(openUrl, sudoMcpUrl, sudoMcpApiKey, authorized_url) {
         // TODO: Keep it on here and pass to `McpServerManager.addMcpServer`
         const apiClient = new sdk_1.ApiClient(sudoMcpUrl ?? sdk_1.DEFAULT_SERVER_URL, sudoMcpApiKey ?? "dummy_key");
         // Fetch server list
         const servers = await apiClient.listServers();
         const [mcpServers, mcpServersMap] = buildServersList(servers);
-        return new SkillManager(mcpServerManager, apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+        return new SkillManager(apiClient, mcpServers, mcpServersMap, new Map(), openUrl, authorized_url);
+    }
+    async shutdown() {
+        return super.shutdown();
     }
     /// TODO: Bit awkward that we have to restore via this class, but it's the
     /// only class which knows how to restore (restart) the mcp servers.
     async restoreMcpSettings(mcpSettings) {
-        await this.restoreConfiguration(mcpSettings);
+        return this.restoreConfiguration(mcpSettings);
     }
     /**
      * Load the configuration from sudomcp, and enable the specified tools.
@@ -73,15 +77,17 @@ class SkillManager {
             }
             if (enabled.length === 0) {
                 logger.debug(` restoring "${serverName}": (all tools)`);
-                this.mcpServerManager.enableAllTools(serverName);
+                this.enableAllTools(serverName);
                 return;
             }
             logger.debug(` restoring "${serverName}": ${JSON.stringify(enabled)}`);
             for (const toolName of enabled) {
-                this.mcpServerManager.enableTool(serverName, toolName);
+                this.enableTool(serverName, toolName);
             }
         };
-        Object.entries(mcpConfig).map((e) => enableTools(e));
+        Object.entries(mcpConfig).map((e) => {
+            enableTools(e);
+        });
     }
     /**
      * Query backend for server list, clear tool cache.
@@ -91,31 +97,28 @@ class SkillManager {
         const [mcpServers, mcpServersMap] = buildServersList(servers);
         this.serverBriefs = mcpServers;
         this.serverBriefsMap = mcpServersMap;
-        this.toolCache = {};
+        this.toolCache = new Map();
     }
-    hasServer(serverName) {
+    hasServerBrief(serverName) {
         return !!this.serverBriefsMap[serverName];
     }
     getServerBriefs() {
         return this.serverBriefs;
     }
-    getMcpServerManager() {
-        return this.mcpServerManager;
-    }
     /**
      * Return tool list for a given MCP server. Queries the backend
      * if necessary and caches the result.
      */
     async getServerTools(serverName) {
         // Check cache
-        let tools = this.toolCache[serverName];
+        let tools = this.toolCache.get(serverName);
         if (tools) {
             return tools;
         }
         // Query backend (using the original name)
         const originalName = this.serverBriefsMap[serverName].originalName;
         tools = await this.apiClient.listTools(originalName);
-        this.toolCache[serverName] = tools;
+        this.toolCache.set(serverName, tools);
         return tools;
     }
     /**
@@ -131,10 +134,9 @@ class SkillManager {
             version: "1.0.0",
         });
         await connectServer(client, this.apiClient, mcpserver, this.openUrl, this.authorized_url);
-        const msm = this.mcpServerManager;
-        await msm.addMcpServerWithClient(client, serverName, tools);
+        await this.addMcpServerWithClient(client, serverName, tools);
         if (enableAll) {
-            msm.enableAllTools(serverName);
+            this.enableAllTools(serverName);
         }
     }
     getOriginalName(serverName) {
@@ -158,9 +160,9 @@ async function connectServer(client, apiClient, mcpServer, openUrl, authorized_u
             logger.info(`authenticate at url: ${url}`);
             openUrl(url, authenticatedP, mcpServer.title);
             const authResult = await authenticatedP;
-            logger.info(`authResult: ${authResult}`);
+            logger.info(`authResult: ${String(authResult)}`);
             if (!authResult) {
-                throw "authentication failed";
+                throw new Error("authentication failed");
             }
             return connectServer(client, apiClient, mcpServer, openUrl, authorized_url, true);
         }

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

@@ -6,16 +6,16 @@ class TokenAuth {
         this.token = token;
     }
     get redirectUrl() {
-        throw "unimpl";
+        throw new Error("unimpl: redirectUrl");
     }
     get clientMetadata() {
-        throw "unimpl";
+        throw new Error("unimpl: clientMetadata");
     }
     clientInformation() {
         return undefined;
     }
     saveClientInformation(_clientInformation) {
-        throw "unimpl";
+        throw new Error("unimpl: saveClientInformation");
     }
     tokens() {
         return {
@@ -24,16 +24,16 @@ class TokenAuth {
         };
     }
     saveTokens(_tokens) {
-        throw "unimpl";
+        throw new Error("unimpl: saveTokens");
     }
     redirectToAuthorization(_authorizationUrl) {
-        throw "unimpl";
+        throw new Error("unimpl: redirectToAuthorization");
     }
     saveCodeVerifier(_codeVerifier) {
-        throw "unimpl";
+        throw new Error("unimpl: saveCodeVerifier");
     }
     codeVerifier() {
-        throw "unimpl";
+        throw new Error("unimpl: codeVerifier");
     }
 }
 exports.TokenAuth = TokenAuth;

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

@@ -35,7 +35,7 @@ exports.toolCallbacks = {
         if (!isTemperatureArgs(args) || !args.location) {
             return `Location required`;
         }
-        return `The temperature in ${args.location} is 22 degrees ${args.unit}`;
+        return `The temperature in ${args.location} is 22 degrees ${args.unit ?? "celsius"}`;
     },
 };
 function displayToolCall(toolCall) {