@xalia/agent 0.5.7 → 0.5.8

package/dist/agent/src/test/openaiStreaming.test.js

@@ -67,6 +67,53 @@ const TEST_TRAILING_USAGE = [
         },
     },
 ];
+const AGGREGATED_MESSAGE = {
+    id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
+    choices: [
+        {
+            message: {
+                content: "test",
+                role: "assistant",
+                refusal: null,
+                tool_calls: undefined,
+            },
+            finish_reason: "stop",
+            index: 0,
+            logprobs: null,
+        },
+    ],
+    created: 1753923406,
+    model: "openai/gpt-4o",
+    object: "chat.completion",
+    service_tier: undefined,
+    system_fingerprint: "fp_a288987b44",
+    usage: {
+        completion_tokens: 50,
+        prompt_tokens: 271,
+        total_tokens: 321,
+        completion_tokens_details: { reasoning_tokens: 0 },
+        prompt_tokens_details: { cached_tokens: 0 },
+    },
+};
+const TEST_TRAILING_USAGE_WITH_3_CHUNKS = [
+    {
+        ...TEST_TRAILING_USAGE[0],
+        choices: [
+            {
+                delta: { content: "test", role: "assistant" },
+                finish_reason: null,
+                index: 0,
+                logprobs: null,
+            },
+        ],
+    },
+    {
+        ...TEST_TRAILING_USAGE[1],
+        choices: [{ ...TEST_TRAILING_USAGE[1].choices[0], finish_reason: "stop" }],
+        usage: undefined,
+    },
+    { ...TEST_TRAILING_USAGE[1], choices: [] },
+];
 describe("OpenAI Streaming", () => {
     it("should support standard termination", async function () {
         const chunks = TEST_STANDARD;
@@ -101,33 +148,14 @@ describe("OpenAI Streaming", () => {
         (0, chai_1.expect)(chunks.length).eql(2);
         const { initMessage } = (0, openAILLMStreaming_1.initializeCompletion)(chunks[0]);
         (0, openAILLMStreaming_1.updateCompletion)(initMessage, chunks[1]);
-        (0, chai_1.expect)(initMessage).eql({
-            id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
-            choices: [
-                {
-                    message: {
-                        content: "test",
-                        role: "assistant",
-                        refusal: null,
-                        tool_calls: undefined,
-                    },
-                    finish_reason: "stop",
-                    index: 0,
-                    logprobs: null,
-                },
-            ],
-            created: 1753923406,
-            model: "openai/gpt-4o",
-            object: "chat.completion",
-            service_tier: undefined,
-            system_fingerprint: "fp_a288987b44",
-            usage: {
-                completion_tokens: 50,
-                prompt_tokens: 271,
-                total_tokens: 321,
-                completion_tokens_details: { reasoning_tokens: 0 },
-                prompt_tokens_details: { cached_tokens: 0 },
-            },
-        });
+        (0, chai_1.expect)(initMessage).eql(AGGREGATED_MESSAGE);
+    });
+    it("should support trailing usage with 3 chunks", async function () {
+        const chunks = TEST_TRAILING_USAGE_WITH_3_CHUNKS;
+        (0, chai_1.expect)(chunks.length).eql(3);
+        const { initMessage } = (0, openAILLMStreaming_1.initializeCompletion)(chunks[0]);
+        (0, openAILLMStreaming_1.updateCompletion)(initMessage, chunks[1]);
+        (0, openAILLMStreaming_1.updateCompletion)(initMessage, chunks[2]);
+        (0, chai_1.expect)(initMessage).eql(AGGREGATED_MESSAGE);
     });
 });

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

@@ -6,38 +6,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prettyPrintTool = prettyPrintTool;
 const chai_1 = require("chai");
 const chalk_1 = __importDefault(require("chalk"));
-const mcpServerManager_1 = require("../agent/mcpServerManager");
 const sudoMcpServerManager_1 = require("../agent/sudoMcpServerManager");
-let managers = undefined;
+let manager = undefined;
 async function getServerManagers() {
-    if (!managers) {
-        const tm = new mcpServerManager_1.McpServerManager();
-        const sm = await sudoMcpServerManager_1.SkillManager.initialize(tm, (_url) => {
+    if (!manager) {
+        manager = await sudoMcpServerManager_1.SkillManager.initialize((_url) => {
             throw "unexpected call to openUrl";
         }, sudoMcpServerManager_1.LOCAL_SERVER_URL, "dummy_key");
-        managers = [tm, sm];
     }
-    return managers;
+    return manager;
 }
 async function shutdownAll() {
-    if (managers) {
-        await managers[0].shutdown();
+    if (manager) {
+        await manager.shutdown();
     }
-    managers = undefined;
+    manager = undefined;
 }
 describe("SudoMcpServerManager", async () => {
     it("should fetch servers from deployed backend", async () => {
-        const [, sm] = await getServerManagers();
+        const sm = await getServerManagers();
         const serverBriefs = sm.getServerBriefs();
         (0, chai_1.expect)(serverBriefs.length).greaterThan(0);
     }).timeout(10000);
     it("should fetch tools for a server", async () => {
-        const [, sm] = await getServerManagers();
+        const sm = await getServerManagers();
         const tools = await sm.getServerTools("sudomcp_simplecalc");
         (0, chai_1.expect)(tools.length).greaterThan(0);
     }).timeout(10000);
     it("should add a new MCP server", async () => {
-        const [, sm] = await getServerManagers();
+        const sm = await getServerManagers();
         await sm.addMcpServer("sudomcp_simplecalc", true);
         const serverBriefs = sm.getServerBriefs();
         (0, chai_1.expect)(serverBriefs.some((brief) => brief.name === "sudomcp_simplecalc")).eql(true);

package/dist/agent/src/tool/chatMain.js

@@ -42,6 +42,7 @@ const tool_1 = require("@xalia/xmcp/tool");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const client_1 = require("../chat/client");
 const server_1 = require("../chat/server");
+const messages_1 = require("../chat/messages");
 const prompt_1 = require("./prompt");
 const options = __importStar(require("./options"));
 const commandPrompt_1 = require("./commandPrompt");
@@ -162,7 +163,12 @@ function getCLIOnMessage() {
                 process_1.stdout.write(`[${msg.from}]: ${msg.message}\n`);
                 break;
             case "agent_msg":
-                process_1.stdout.write(`[AGENT]: ${msg.message}\n`);
+                {
+                    const text = (0, messages_1.decodeAssistantMessageParam)(msg.message);
+                    if (text) {
+                        process_1.stdout.write(`[AGENT]: ${text}\n`);
+                    }
+                }
                 break;
             case "agent_msg_chunk":
                 if (startMsg) {

package/dist/agent/src/tool/commandPrompt.js

@@ -84,17 +84,17 @@ class CommandPrompt {
                     break;
             }
             try {
-                await this.runCommand(agent, sudoMcpServerManager.getMcpServerManager(), sudoMcpServerManager, cmds);
+                await this.runCommand(agent, sudoMcpServerManager, cmds);
             }
             catch (e) {
                 console.log(`ERROR: ${e}`);
             }
         }
     }
-    async runCommand(agent, mcpServerManager, sudoMcpServerManager, cmds) {
+    async runCommand(agent, sudoMcpServerManager, cmds) {
         switch (cmds[0]) {
             case "lt":
-                this.listTools(mcpServerManager);
+                this.listTools(sudoMcpServerManager);
                 break;
             case "ls":
                 this.listServers(sudoMcpServerManager);
@@ -103,22 +103,22 @@ class CommandPrompt {
                 await this.addServer(sudoMcpServerManager, cmds[1]);
                 break;
             case "rs":
-                await mcpServerManager.removeMcpServer(cmds[1]);
+                await sudoMcpServerManager.removeMcpServer(cmds[1]);
                 break;
             case "e":
-                mcpServerManager.enableTool(cmds[1], cmds[2]);
+                sudoMcpServerManager.enableTool(cmds[1], cmds[2]);
                 console.log(`Enabled tool ${cmds[2]} for server ${cmds[1]}`);
                 break;
             case "d":
-                mcpServerManager.disableTool(cmds[1], cmds[2]);
+                sudoMcpServerManager.disableTool(cmds[1], cmds[2]);
                 console.log(`Disabled tool ${cmds[2]} for server ${cmds[1]}`);
                 break;
             case "ea":
-                mcpServerManager.enableAllTools(cmds[1]);
+                sudoMcpServerManager.enableAllTools(cmds[1]);
                 console.log(`Enabled all tools for server ${cmds[1]}`);
                 break;
             case "da":
-                mcpServerManager.disableAllTools(cmds[1]);
+                sudoMcpServerManager.disableAllTools(cmds[1]);
                 console.log(`Disabled all tools for server ${cmds[1]}`);
                 break;
             case "wc":
@@ -189,10 +189,9 @@ Have you installed server ${serverName} using the SudoMCP CLI tool?`;
                 throw e;
             }
         }
-        const msm = sudoMcpServerManager.getMcpServerManager();
         console.log(`Added server: ${serverName} (enabled all tools).`);
         console.log(`Current tool list:`);
-        this.listTools(msm);
+        this.listTools(sudoMcpServerManager);
     }
     writeConversation(agent, fileName) {
         const conversation = agent.getConversation();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xalia/agent",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "keywords": [],
   "author": "",
   "license": "ISC",

package/src/agent/agent.ts

@@ -1,10 +1,7 @@
 import * as dotenv from "dotenv";
 import { OpenAI } from "openai";
 import { McpServerManager } from "./mcpServerManager";
-import {
-  ChatCompletionContentPart,
-  ChatCompletionUserMessageParam,
-} from "openai/resources.mjs";
+import { ChatCompletionContentPart } from "openai/resources.mjs";
 import { strict as assert } from "assert";
 import { ILLM } from "./llm";
 import { AgentProfile, getLogger } from "@xalia/xmcp/sdk";
@@ -19,6 +16,12 @@ export type ChatCompletionMessageParam = OpenAI.ChatCompletionMessageParam;
 export type ChatCompletionMessageToolCall =
   OpenAI.ChatCompletionMessageToolCall;
 
+export type ChatCompletionAssistantMessageParam =
+  OpenAI.ChatCompletionAssistantMessageParam;
+
+export type ChatCompletionUserMessageParam =
+  OpenAI.ChatCompletionUserMessageParam;
+
 // Role: If content, give it to UI
 export type OnMessageCB = {
   (msg: string, msgEnd: boolean): Promise<void>;
@@ -41,6 +44,8 @@ export interface IConversation {
   setSystemPrompt(systemPrompt: string): void;
   getModel(): string;
   setModel(model: string): void;
+
+  shutdown(): Promise<void>;
 }
 
 dotenv.config();
@@ -132,7 +137,12 @@ export class Agent implements IConversation {
     if (!userMessage) {
       return undefined;
     }
+    return this.userMessageRaw(userMessage);
+  }
 
+  public async userMessageRaw(
+    userMessage: ChatCompletionUserMessageParam
+  ): Promise<ChatCompletionMessageParam | undefined> {
     this.messages.push(userMessage);
     let completion = await this.chatCompletion();
 

package/src/agent/agentUtils.ts

@@ -34,7 +34,7 @@ async function createAgent(
   platform: IPlatform,
   openaiApiKey: string | undefined,
   stream: boolean = false,
-  mcpServerManager?: McpServerManager
+  mcpServerManager: McpServerManager
 ): Promise<Agent> {
   let llm: ILLM | undefined;
 
@@ -90,26 +90,9 @@ export async function createAgentWithSkills(
   conversation: OpenAI.ChatCompletionMessageParam[] | undefined,
   stream: boolean = false
 ): Promise<[Agent, SkillManager]> {
-  // Create agent
-  logger.debug("[createAgentAndSudoMcpServerManager] creating agent ...");
-  const agent = await createAgent(
-    llmUrl,
-    agentProfile.model,
-    agentProfile.system_prompt,
-    onMessage,
-    onToolCall,
-    platform,
-    llmApiKey,
-    stream
-  );
-  if (conversation) {
-    agent.setConversation(conversation);
-  }
-
   // Init SudoMcpServerManager
   logger.debug("[createAgentWithSkills] creating SudoMcpServerManager.");
   const sudoMcpServerManager = await SkillManager.initialize(
-    agent.getMcpServerManager(),
     platform.openUrl,
     sudomcpConfig.backend_url,
     sudomcpConfig.api_key,
@@ -121,7 +104,19 @@ export async function createAgentWithSkills(
   );
   await sudoMcpServerManager.restoreMcpSettings(agentProfile.mcp_settings);
 
-  logger.debug("[createAgentWithSkills] done");
+  // Create agent using the McpServerManager just created
+  const agent = await createAgentFromSkillManager(
+    llmUrl,
+    agentProfile,
+    onMessage,
+    onToolCall,
+    platform,
+    llmApiKey,
+    sudoMcpServerManager,
+    conversation,
+    stream
+  );
+
   return [agent, sudoMcpServerManager];
 }
 
@@ -137,8 +132,7 @@ export async function createAgentFromSkillManager(
   stream: boolean = false
 ): Promise<Agent> {
   // Create agent
-  logger.debug("[createAgentAndSudoMcpServerManager] creating agent ...");
-  const mcpServerManager = skillManager.getMcpServerManager();
+  logger.debug("[createAgentFromSkillManager] creating agent ...");
   const agent = await createAgent(
     llmUrl,
     agentProfile.model,
@@ -148,13 +142,13 @@ export async function createAgentFromSkillManager(
     platform,
     llmApiKey,
     stream,
-    mcpServerManager
+    skillManager
   );
   if (conversation) {
     agent.setConversation(conversation);
   }
 
-  logger.debug("[createAgentWithSkills] done");
+  logger.debug("[createAgentFromSkillManager] done");
   return agent;
 }
 

package/src/agent/mcpServerManager.ts

@@ -151,6 +151,8 @@ export interface IMcpServerManager {
   disableAllTools(mcpServerName: string): void;
   enableTool(mcpServerName: string, toolName: string): void;
   disableTool(mcpServerName: string, toolName: string): void;
+
+  shutdown(): Promise<void>;
 }
 
 /**
@@ -186,7 +188,7 @@ export class McpServerManager implements IMcpServerManager {
     return this.getMcpServerInternal(mcpServerName);
   }
 
-  public async addMcpServer(
+  public async addMcpServerWithSSEUrl(
     mcpServerName: string,
     url: string,
     apiKey?: string,

package/src/agent/openAILLMStreaming.ts

@@ -316,9 +316,10 @@ function initializeCompletionChoices(
   chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
 ): { choices: OpenAI.Chat.Completions.ChatCompletion.Choice[]; done: boolean } {
   // 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.
   assert(chunkChoices.length < 2);
 
   let msgDone = false;
@@ -339,10 +340,11 @@ function updateCompletionChoices(
   chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
 ): boolean {
   // 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.
-  assert(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.
+  assert(chunkChoices.length < 2);
   assert(completionChoices.length === 1);
 
   let msgDone = false;
@@ -481,6 +483,9 @@ export class OpenAILLMStreaming implements ILLM {
       messages,
       tools,
       stream: true,
+      stream_options: {
+        include_usage: true,
+      },
     });
 
     // Check the type casting above
@@ -507,6 +512,8 @@ export class OpenAILLMStreaming implements ILLM {
 
       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;
         if (delta?.content) {

package/src/agent/sudoMcpServerManager.ts

@@ -40,11 +40,10 @@ class SanitizedServerBrief extends McpServerBrief {
 }
 
 /**
- * A manager which can expose a set of mcp servers and set them to an
- * McpServerManager.
+ * An McpServerManager which can list a set of servers, and enable them in
+ * response to requests.
  */
-export interface ISkillManager {
-  getMcpServerManager(): IMcpServerManager;
+export interface ISkillManager extends IMcpServerManager {
   getServerBriefs(): McpServerBrief[];
 
   /**
@@ -55,15 +54,16 @@ export interface ISkillManager {
    * is enabled.
    */
   addMcpServer(serverName: string, enableAll: boolean): Promise<void>;
+
+  shutdown(): Promise<void>;
 }
 
 /**
  * Manages access to the catalogue of servers hosted by sudomcp.  Supports
  * adding these servers to McpServerManager.
  */
-export class SkillManager implements ISkillManager {
+export class SkillManager extends McpServerManager implements ISkillManager {
   private constructor(
-    private mcpServerManager: McpServerManager,
     private apiClient: ApiClient,
     private serverBriefs: SanitizedServerBrief[],
     private serverBriefsMap: { [serverName: string]: SanitizedServerBrief },
@@ -75,14 +75,15 @@ export class SkillManager implements ISkillManager {
     ) => void,
     // Redirect to this page after successful authorization
     private authorized_url: string | undefined
-  ) {}
+  ) {
+    super();
+  }
 
   /**
    * Initialize an ApiClient to interface with SudoMCP backend and
    * fetch the current list of ServerBriefs.
    */
   public static async initialize(
-    mcpServerManager: McpServerManager,
     openUrl: (
       url: string,
       authResultP: Promise<boolean>,
@@ -102,7 +103,6 @@ export class SkillManager implements ISkillManager {
 
     const [mcpServers, mcpServersMap] = buildServersList(servers);
     return new SkillManager(
-      mcpServerManager,
       apiClient,
       mcpServers,
       mcpServersMap,
@@ -112,6 +112,10 @@ export class SkillManager implements ISkillManager {
     );
   }
 
+  public async shutdown(): Promise<void> {
+    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.
   public async restoreMcpSettings(
@@ -143,13 +147,13 @@ export class SkillManager implements ISkillManager {
       }
       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));
@@ -174,10 +178,6 @@ export class SkillManager implements ISkillManager {
     return this.serverBriefs;
   }
 
-  public getMcpServerManager(): McpServerManager {
-    return this.mcpServerManager;
-  }
-
   /**
    * Return tool list for a given MCP server. Queries the backend
    * if necessary and caches the result.
@@ -219,10 +219,9 @@ export class SkillManager implements ISkillManager {
       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);
     }
   }