@xalia/agent 0.6.2 → 0.6.4

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -485,15 +485,16 @@ class SessionRegistry {
     async getAndActivateSession(sessionId) {
         if (this.openSessions.has(sessionId)) {
             logger.info(`[SessionRegistry] Session ${sessionId} already exists`);
-            const openSession = this.openSessions.get(sessionId);
-            if (!openSession) {
+            const session = this.openSessions.get(sessionId);
+            if (!session) {
                 throw new errors_1.ChatFatalError(`Internal error: No such session: ${sessionId}`);
             }
-            return openSession;
+            return { session, isNew: false };
         }
         else {
             logger.info(`[SessionRegistry] loading session ${sessionId}`);
-            return openSession_1.OpenSession.initWithExistingSession(this.db, sessionId, this.llmUrl, this.xmcpUrl, this.connectionManager);
+            const session = await openSession_1.OpenSession.initWithExistingSession(this.db, sessionId, this.llmUrl, this.xmcpUrl, this.connectionManager);
+            return { session, isNew: true };
         }
     }
     /**
@@ -511,12 +512,13 @@ class SessionRegistry {
                 throw new errors_1.ChatFatalError(`User ${userId} is not authorized to join session ${sessionId}`);
             }
             // get or create the session
-            const session = await this.getAndActivateSession(sessionId);
-            if (!session) {
+            const sessionInfo = await this.getAndActivateSession(sessionId);
+            if (!sessionInfo) {
                 // this in theory should not happen
                 // since we have validated the access
                 throw new errors_1.ChatFatalError(`Server internal error: ` + `failed to load session ${sessionId}`);
             }
+            const { session, isNew } = sessionInfo;
             const guest = this.guests.get(userId);
             if (guest) {
                 session.addParticipant(userId, {
@@ -534,7 +536,7 @@ class SessionRegistry {
                 this.openSessions.set(sessionId, session);
             }
             // pass the message to the session to handle the rest
-            session.sendSessionData(connectionId, message.client_message_id);
+            await session.sendSessionData(connectionId, message.client_message_id, isNew);
         }
         catch (error) {
             logger.error(`[SessionRegistry] Error handling user join: ${String(error)}`);
@@ -638,8 +640,9 @@ class SessionRegistry {
             this.openSessions.set(sessionId, openSession);
             // add owner to session memory
             this.addUserToSessionMemory(fromUserId, sessionId);
-            // send session info to the connection
-            openSession.sendSessionData(connectionId, message.client_message_id);
+            // send session info to the connection.  It has just been created so we
+            // must also restore the mcp servers.
+            await openSession.sendSessionData(connectionId, message.client_message_id, true);
             logger.info(`[SessionRegistry] new session ${sessionId}:` +
                 ` ${message.title} for ${fromUserId}`);
         }
@@ -667,15 +670,16 @@ class SessionRegistry {
      */
     async newTeamSession(fromUserId, teamId, title, agentProfileId) {
         // validate agent profile and team access
-        const [_savedAgentProfile, access] = await Promise.all([
+        const [_savedAgentProfile, access, participants] = await Promise.all([
             this.validateSavedAgentProfile(agentProfileId),
             this.validateTeamAccess(teamId, fromUserId),
+            this.db.teamGetMembers(teamId),
         ]);
         if (!access) {
             throw new errors_1.ChatFatalError(`User ${fromUserId} is not a participant of team ${teamId}`);
         }
         const newSessionData = {
-            ...teamSessionCreateData(teamId, fromUserId, title, agentProfileId),
+            ...teamSessionCreateData(teamId, participants, fromUserId, title, agentProfileId),
             updated_at: new Date().toISOString(),
         };
         // initialize the open session
@@ -855,11 +859,12 @@ function userSessionCreateData(ownerId, title, agentProfileId) {
         agent_paused: false,
     };
 }
-function teamSessionCreateData(teamId, ownerId, title, agentProfileId) {
+function teamSessionCreateData(teamId, participants, ownerId, title, agentProfileId) {
     return {
         session_uuid: database_1.Database.sessionNewUUID(),
         title,
         team_uuid: teamId,
+        participants,
         agent_profile_uuid: agentProfileId,
         user_uuid: ownerId,
         agent_paused: false,

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

@@ -1,85 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApprovalManager = exports.ApprovalCancelled = exports.ApprovalTimeout = void 0;
+exports.ToolApprovalManager = exports.DbAgentPreferencesWriter = void 0;
 const sdk_1 = require("@xalia/xmcp/sdk");
+const responseAwaiter_1 = require("./responseAwaiter");
 const logger = (0, sdk_1.getLogger)();
-/**
- * Thrown in the resultP promise when an approval times out.
- */
-class ApprovalTimeout extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ApprovalTimeout";
+class DbAgentPreferencesWriter {
+    constructor(db) {
+        this.db = db;
     }
-}
-exports.ApprovalTimeout = ApprovalTimeout;
-class ApprovalCancelled extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ApprovalCancelled";
+    updatePreferences(agentProfileUUID, preferences) {
+        return this.db.updateAgentProfilePreferences(agentProfileUUID, preferences);
     }
 }
-exports.ApprovalCancelled = ApprovalCancelled;
+exports.DbAgentPreferencesWriter = DbAgentPreferencesWriter;
 /**
- * The caller initiates an approval for a specific server, and a unique ID is
- * generated for it, along with a promise for the resolution of the approval.
- * The caller returns the ID to some client(s) and waits on the promise.
- *
- * When an approval or rejection (or timeout) is received, the promise is
- * resolved.
+ * Handles an in-memory caching / updating of the auto-approve settings for
+ * tool calls.  Also handles querying the client for approval and waiting for
+ * responses.
  */
-class ApprovalManager {
-    constructor(timeoutMs) {
-        this.approvals = new Map();
-        this.timeoutMs = timeoutMs;
+class ToolApprovalManager {
+    constructor(sessionUUID, agentProfileUUID, agentProfilePreferences, sender, writer, timeoutMs) {
+        this.sessionUUID = sessionUUID;
+        this.agentProfileUUID = agentProfileUUID;
+        this.agentProfilePreferences = agentProfilePreferences;
+        this.sender = sender;
+        this.writer = writer;
+        this.responseAwaiter = responseAwaiter_1.ResponseAwaiter.init(undefined, (msg) => msg.id, timeoutMs);
     }
-    shutdown() {
-        for (const [id, approval] of this.approvals) {
-            if (approval.timeoutId) {
-                clearTimeout(approval.timeoutId);
-            }
-            approval.error(new ApprovalCancelled("shutdown"));
-            this.approvals.delete(id);
+    /**
+     * Check for auto-approval, or query the client.  Handle approval response
+     * (or timeout) and update auto-approval settings.
+     *
+     * The returned `requested` value indicates whether approval was requested.
+     */
+    async getApproval(serverName, tool, toolCall) {
+        const autoApproved = (0, sdk_1.prefsGetAutoApprove)(this.agentProfilePreferences, serverName, tool);
+        if (autoApproved) {
+            return { approved: true, requested: false };
         }
-    }
-    startApproval(name) {
-        const id = this.generateUniqueId(name);
-        const resultP = new Promise((resolve, error) => {
-            let timeoutId;
-            if (this.timeoutMs) {
-                timeoutId = setTimeout(() => {
-                    const approval = this.approvals.get(id);
-                    if (approval) {
-                        this.approvals.delete(id);
-                        error(new ApprovalTimeout(`approval ${id} (${name}) timed out`));
-                    }
-                }, this.timeoutMs);
+        // Query the owner for approval
+        const id = this.generateUniqueId(toolCall.function.name);
+        try {
+            const approvalP = this.responseAwaiter.waitForResponse(id);
+            this.sender.broadcast({
+                type: "approve_tool_call",
+                id,
+                tool_call: toolCall,
+                session_id: this.sessionUUID,
+            });
+            logger.debug(`[ApprovalManager.getApproval] awaiting approval ${id}`);
+            const approval = await approvalP;
+            logger.debug(`[ApprovalManager.getApproval] approval ${JSON.stringify(approval)}`);
+            // 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);
+                if (autoApprovalMsg) {
+                    this.sender.broadcast(autoApprovalMsg);
+                }
             }
-            this.approvals.set(id, { resolve, error, timeoutId });
-        });
-        logger.debug(`new approval ${id}`);
-        return { id, resultP };
+            // Broadcast the result of the approval
+            this.sender.broadcast({
+                type: "tool_call_approval_result",
+                id: approval.id,
+                result: approval.result,
+                session_id: this.sessionUUID,
+            });
+            return { approved: approval.result, requested: true };
+        }
+        catch (e) {
+            logger.debug(`[OpenSession.onToolCall] error waiting for approval ${id}: ` +
+                String(e));
+            throw e;
+        }
     }
     /**
-     * Returns true if this result was accepted.  False if the approval was
-     * already answered.
+     * Handle a request to set auto-approval for a given tool.  If there was a
+     * change, return the message to be broadcast.
      */
-    approvalResult(id, approved, auto_approve) {
-        const approval = this.approvals.get(id);
-        if (approval) {
-            logger.debug(`approval ${id} present.  resolving ${String(approved)}`);
-            if (approval.timeoutId) {
-                clearTimeout(approval.timeoutId);
-            }
-            this.approvals.delete(id);
-            approval.resolve({ approved, auto_approve });
-            return true;
+    async setAutoApprove(serverName, tool, autoApprove) {
+        if ((0, sdk_1.prefsSetAutoApprove)(this.agentProfilePreferences, serverName, tool, autoApprove)) {
+            await this.writer.updatePreferences(this.agentProfileUUID, this.agentProfilePreferences);
+            return {
+                type: "tool_auto_approval_set",
+                server_name: serverName,
+                tool,
+                auto_approve: autoApprove,
+                session_id: this.sessionUUID,
+            };
         }
-        logger.debug(`approval ${id} not present`);
-        return false;
+    }
+    /**
+     * Forward all approval result messages here.
+     */
+    onApprovalResult(msg) {
+        this.responseAwaiter.onMessage(msg);
     }
     generateUniqueId(tag) {
         return `approval-${tag}-` + Math.random().toString(36).substring(2, 11);
     }
 }
-exports.ApprovalManager = ApprovalManager;
+exports.ToolApprovalManager = ToolApprovalManager;

package/dist/agent/src/chat/{client/responseHandler.js → utils/responseAwaiter.js}

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseHandler = void 0;
+exports.ResponseAwaiter = void 0;
 const sdk_1 = require("@xalia/xmcp/sdk");
 const DEFAULT_TIMEOUT_MS = 10000;
 const logger = (0, sdk_1.getLogger)();
+function defaultImmediate(x) {
+    return x;
+}
 /**
  *
  * Handles response messages and timeouts for client request messages.
  *
- * Create a ResponseHandler for a specific class of queries
+ * Create a ResponseAwaiter for a specific class of queries
  *
- *   this.responseHandler = new ResponseHandler<SomeRequest, SomeResponse>()
+ *   this.responseHandler = new ResponseAwaiter<SomeRequest, SomeResponse>(
+ *     (msg: SomeResponse) => msg.client_message_id;
+ *   )
  *
  * Use as follows:
  *
@@ -24,14 +29,15 @@ const logger = (0, sdk_1.getLogger)();
  *
  *     // Get a Promise representing the response to this message, which
  *     // we can await.
- *     const response = await this.responseHandler.waitForResponse(msg);
+ *     const response =
+ *       await this.responseHandler.waitForResponse(client_message_id);
  *
  *     // Perform any processing on the response
  *     return response.response_data;
  *   }
  *   ```
  *
- * ResponseHandler must be informed of relevant messages in order to resolve
+ * ResponseAwaiter must be informed of relevant messages in order to resolve
  * responses:
  *
  *   ```
@@ -45,8 +51,13 @@ const logger = (0, sdk_1.getLogger)();
  *     }
  *   }
  *   ```
+ *
+ * If some actions need to happen immediately on receipt of the message,
+ * instead of when the `Promise.resolve` function is resolved, add an
+ * `immediateAction` callback, which can optionally transfrom `ServerMsgT`
+ * into `FinalResponseT` to be passed back by `waitForResponse`.
  */
-class ResponseHandler {
+class ResponseAwaiter {
     /**
      * errorType: the type field of the message which represents an error.
      */
@@ -54,43 +65,54 @@ class ResponseHandler {
     // value of the `type` field of an error message type,
     // e.g. "session_error". Compiler should ensure that the `ServerMsgT` with
     // this `type` field at least has a `message` field.
-    errorType, timeoutMS = DEFAULT_TIMEOUT_MS) {
+    errorType, idExtractor, immediateAction, timeoutMS = DEFAULT_TIMEOUT_MS) {
         this.waiting = new Map();
+        this.idExtractor = idExtractor;
+        this.immediateAction = immediateAction;
         this.timeoutMS = timeoutMS;
         this.errorType = errorType;
     }
+    static init(errorType, idExtractor, timeoutMS = DEFAULT_TIMEOUT_MS) {
+        return new ResponseAwaiter(errorType, idExtractor, defaultImmediate, timeoutMS);
+    }
+    static initWithImmediate(errorType, idExtractor, immediateAction, timeoutMS = DEFAULT_TIMEOUT_MS) {
+        return new ResponseAwaiter(errorType, idExtractor, immediateAction, timeoutMS);
+    }
     /**
      * Given a request message, return a promise representing the corresponding
      * response message from the server.
      */
-    waitForResponse(msg) {
+    waitForResponse(msgId) {
         return new Promise((resolve, error) => {
-            const msgId = msg.client_message_id;
             const timeoutId = setTimeout(() => {
                 const waiting = this.waiting.get(msgId);
                 if (!waiting) {
-                    logger.warn(`[ResponseHandler] timeout for ${msgId} with no entry`);
+                    logger.warn(`[ResponseAwaiter] timeout for ${msgId} with no entry`);
                     return;
                 }
                 this.waiting.delete(msgId);
-                logger.warn(`[ResponseHandler] timeout for client_msg_id ${msgId}`);
+                logger.warn(`[ResponseAwaiter] timeout for client_msg_id ${msgId}`);
                 error(new Error(`timeout for client_msg_id ${msgId}`));
             }, this.timeoutMS);
             this.waiting.set(msgId, { resolve, error, timeoutId });
         });
     }
+    waitingForId(msgId) {
+        return this.waiting.has(msgId);
+    }
     /**
-     * Pass response (and error) messages in here.
+     * Pass response (and error) messages in here.  Returns `true` if the
+     * message was consumed.  Otherwise `false`.
      */
     onMessage(msg) {
-        const msgId = msg.client_message_id;
+        const msgId = this.idExtractor(msg);
         if (!msgId) {
-            return;
+            return false;
         }
         const waiting = this.waiting.get(msgId);
         if (!waiting) {
-            logger.warn(`[ResponseHandler] resolve for ${msgId} with no entry (timeout?)`);
-            return;
+            logger.warn(`[ResponseAwaiter] resolve for ${msgId} with no entry (timeout?)`);
+            return false;
         }
         clearTimeout(waiting.timeoutId);
         this.waiting.delete(msgId);
@@ -98,8 +120,9 @@ class ResponseHandler {
             waiting.error(new Error(msg.message));
         }
         else {
-            waiting.resolve(msg);
+            waiting.resolve(this.immediateAction(msg));
         }
+        return true;
     }
 }
-exports.ResponseHandler = ResponseHandler;
+exports.ResponseAwaiter = ResponseAwaiter;

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

@@ -33,8 +33,24 @@ const DUMMY_SCRIPT = [
     },
 ];
 function createCallTestToolScript(tool_call_ids, param1, param2) {
+    // A tool with no args
+    const tool0_params = {
+        type: "object",
+        properties: {},
+    };
+    const tool0_descriptor = {
+        type: "function",
+        function: {
+            name: "tool0",
+            parameters: tool0_params,
+            strict: true,
+        },
+    };
+    const tool0_fn = (_, _args) => {
+        return Promise.resolve({ response: "0" });
+    };
     // A trivial tool
-    const parameters = {
+    const test_tool_params = {
         type: "object",
         properties: {
             param1: {
@@ -46,15 +62,15 @@ function createCallTestToolScript(tool_call_ids, param1, param2) {
         },
         required: ["param1", "param2"],
     };
-    const toolDescriptor = {
+    const test_tool_descriptor = {
         type: "function",
         function: {
             name: "test_tool",
-            parameters,
+            parameters: test_tool_params,
             strict: true,
         },
     };
-    const toolFn = async (_, args) => {
+    const test_tool_fn = async (_, args) => {
         const { param1, param2 } = args;
         return new Promise((r) => {
             r({
@@ -63,7 +79,48 @@ function createCallTestToolScript(tool_call_ids, param1, param2) {
             });
         });
     };
-    // A script that uses the tool
+    const tool_calls = [];
+    const expectToolResults = [];
+    // First tool call (if requested) is test_tool
+    if (tool_call_ids.length > 0) {
+        const id = tool_call_ids[0];
+        tool_calls.push({
+            id,
+            function: {
+                name: "test_tool",
+                arguments: JSON.stringify({ param1, param2 }),
+            },
+            type: "function",
+        });
+        expectToolResults.push({
+            content: `tool_result: '${param1}' '${String(param2)}'`,
+            role: "tool",
+            tool_call_id: id,
+            metadata: { type: "text/plain" },
+        });
+    }
+    // Second tool call (if requested) is tool0
+    if (tool_call_ids.length > 1) {
+        const id = tool_call_ids[1];
+        tool_calls.push({
+            id,
+            function: {
+                name: "tool0",
+                arguments: "",
+            },
+            type: "function",
+        });
+        expectToolResults.push({
+            content: "0",
+            role: "tool",
+            tool_call_id: id,
+        });
+    }
+    // 3 calls not supported
+    if (tool_call_ids.length > 2) {
+        throw new Error("3 toolc alls not supported in this test");
+    }
+    // A script that uses the tools
     const script = [
         {
             index: 0,
@@ -72,16 +129,7 @@ function createCallTestToolScript(tool_call_ids, param1, param2) {
                 content: "calling test_tool.",
                 refusal: null,
                 role: "assistant",
-                tool_calls: tool_call_ids.map((t_id) => {
-                    return {
-                        id: t_id,
-                        function: {
-                            name: "test_tool",
-                            arguments: JSON.stringify({ param1, param2 }),
-                        },
-                        type: "function",
-                    };
-                }),
+                tool_calls,
             },
             logprobs: null,
         },
@@ -101,21 +149,15 @@ function createCallTestToolScript(tool_call_ids, param1, param2) {
         "calling test_tool.",
         "message after tools calls.",
     ];
-    const expectToolResults = tool_call_ids.map((t_id) => {
-        return {
-            content: `tool_result: '${param1}' '${String(param2)}'`,
-            role: "tool",
-            tool_call_id: t_id,
-            metadata: { type: "text/plain" },
-        };
-    });
     return {
         script,
         expectCompletions: script.map((s) => (0, agent_1.completionToAssistantMessageParam)(s.message)),
         expectAgentMessages,
         expectToolResults,
-        toolDescriptor,
-        toolFn,
+        tool0_descriptor,
+        tool0_fn,
+        test_tool_descriptor,
+        test_tool_fn,
     };
 }
 /// Return a dummy agent and a TestAgentEventHandler for tracking messages.
@@ -137,9 +179,10 @@ describe("Agent", () => {
         const tool_call_id = "tool_call_1";
         const param1 = "first param";
         const param2 = 2;
-        const { script, expectAgentMessages, expectToolResults, toolDescriptor, toolFn, } = createCallTestToolScript([tool_call_id], param1, param2);
+        const { script, expectAgentMessages, expectToolResults, tool0_descriptor, tool0_fn, test_tool_descriptor, test_tool_fn, } = createCallTestToolScript([tool_call_id], param1, param2);
         const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
-        agent.addAgentTool(toolDescriptor, toolFn);
+        agent.addAgentTool(tool0_descriptor, tool0_fn);
+        agent.addAgentTool(test_tool_descriptor, test_tool_fn);
         await agent.userMessageEx("user message 1");
         (0, vitest_1.expect)(eventHandler.getAgentMessages()).eql(expectAgentMessages);
         (0, vitest_1.expect)(eventHandler.getToolCallResults()).eql(expectToolResults);
@@ -161,14 +204,14 @@ describe("Agent", () => {
         const tool_call_id = "tool_call_1";
         const param1 = "asdf";
         const param2 = 3;
-        const { script, expectCompletions, expectAgentMessages, expectToolResults, toolDescriptor, toolFn, } = createCallTestToolScript([tool_call_id], param1, param2);
+        const { script, expectCompletions, expectAgentMessages, expectToolResults, test_tool_descriptor, test_tool_fn, } = createCallTestToolScript([tool_call_id], param1, param2);
         const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
         const toolProvider = {
             setup: (agent) => {
                 // Add the tool async to test this mechanism
                 return new Promise((r) => {
                     setTimeout(() => {
-                        agent.addAgentTool(toolDescriptor, toolFn);
+                        agent.addAgentTool(test_tool_descriptor, test_tool_fn);
                         r();
                     });
                 });
@@ -203,16 +246,13 @@ describe("Agent", () => {
         (0, vitest_1.expect)(agent.getSystemPrompt()).eql("agent_prompt_2");
     });
     it("correctly orders messages for multiple tool calls", async function () {
-        const tool_call_ids = [
-            "tool_call_1",
-            "tool_call_2",
-            "tool_call_3",
-        ];
+        const tool_call_ids = ["tool_call_1", "tool_call_2"];
         const param1 = "asdf";
         const param2 = 3;
-        const { script, expectToolResults, toolDescriptor, toolFn } = createCallTestToolScript(tool_call_ids, param1, param2);
+        const { script, expectToolResults, test_tool_descriptor, test_tool_fn, tool0_descriptor, tool0_fn, } = createCallTestToolScript(tool_call_ids, param1, param2);
         const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
-        agent.addAgentTool(toolDescriptor, toolFn);
+        agent.addAgentTool(test_tool_descriptor, test_tool_fn);
+        agent.addAgentTool(tool0_descriptor, tool0_fn);
         await agent.userMessageEx("user message 1");
         // Check the event handler was called with all completions and tool
         // results, in the correct order.
@@ -229,14 +269,10 @@ describe("Agent", () => {
         (0, vitest_1.expect)(conv.slice(1)).eql(all);
     });
     it("correctly updates tool call args", async function () {
-        const tool_call_ids = [
-            "tool_call_1",
-            "tool_call_2",
-            "tool_call_3",
-        ];
+        const tool_call_ids = ["tool_call_1", "tool_call_2"];
         const param1 = "asdf";
         const param2 = 3;
-        const { script, expectToolResults, toolDescriptor, toolFn } = createCallTestToolScript(tool_call_ids, param1, param2);
+        const { script, expectToolResults, test_tool_descriptor, test_tool_fn, tool0_descriptor, tool0_fn, } = createCallTestToolScript(tool_call_ids, param1, param2);
         const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
         // Take a copy of the script now, since this will be updated when the
         // tools redacted their args.
@@ -249,11 +285,12 @@ describe("Agent", () => {
             return JSON.stringify(transformArgs(args));
         };
         const newToolFn = async (agent, args) => {
-            const result = await toolFn(agent, args);
+            const result = await test_tool_fn(agent, args);
             result.overwriteArgs = JSON.stringify(transformArgs(args));
             return result;
         };
-        agent.addAgentTool(toolDescriptor, newToolFn);
+        agent.addAgentTool(test_tool_descriptor, newToolFn);
+        agent.addAgentTool(tool0_descriptor, tool0_fn);
         // Send a message and trigger the tool calls
         await agent.userMessageEx("user message 1");
         // Check the event handler was called with all completions and tool
@@ -270,7 +307,10 @@ describe("Agent", () => {
         (0, assert_1.strict)(scriptCopy[0].message.tool_calls);
         const transformedFirstMsg = (0, agent_1.completionToAssistantMessageParam)({
             ...scriptCopy[0].message,
-            tool_calls: scriptCopy[0].message.tool_calls.map(transformToolCall),
+            tool_calls: [
+                transformToolCall(scriptCopy[0].message.tool_calls[0]),
+                scriptCopy[0].message.tool_calls[1],
+            ],
         });
         const allExpect = [
             transformedFirstMsg,
@@ -283,14 +323,10 @@ describe("Agent", () => {
         (0, vitest_1.expect)(conv.slice(1)).eql(all);
     });
     it("correctly updates tool call results", async function () {
-        const tool_call_ids = [
-            "tool_call_1",
-            "tool_call_2",
-            "tool_call_3",
-        ];
+        const tool_call_ids = ["tool_call_1", "tool_call_2"];
         const param1 = "asdf";
         const param2 = 3;
-        const { script, expectToolResults, toolDescriptor, toolFn } = createCallTestToolScript(tool_call_ids, param1, param2);
+        const { script, expectToolResults, test_tool_descriptor, test_tool_fn, tool0_descriptor, tool0_fn, } = createCallTestToolScript(tool_call_ids, param1, param2);
         const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
         // Define the tool to update the results.  The transform is to up-case
         // the whole result string.
@@ -298,11 +334,12 @@ describe("Agent", () => {
             return result.toUpperCase();
         };
         const newToolFn = async (agent, args) => {
-            const result = await toolFn(agent, args);
+            const result = await test_tool_fn(agent, args);
             result.overwriteResponse = transformResult(result.response);
             return result;
         };
-        agent.addAgentTool(toolDescriptor, newToolFn);
+        agent.addAgentTool(tool0_descriptor, tool0_fn);
+        agent.addAgentTool(test_tool_descriptor, newToolFn);
         // Send a message and trigger the tool calls
         await agent.userMessageEx("user message 1");
         // Check the event handler was called with all completions and tool