@xalia/agent 0.5.7 → 0.6.0

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

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assert_1 = require("assert");
+const agent_1 = require("../agent/agent");
+const context_1 = require("../agent/context");
+const sudoMcpServerManager_1 = require("../agent/sudoMcpServerManager");
+const promptProvider_1 = require("../agent/promptProvider");
+const testTools_1 = require("./testTools");
+function clone(a) {
+    return JSON.parse(JSON.stringify(a));
+}
+const DUMMY_SCRIPT = [
+    {
+        index: 0,
+        finish_reason: "stop",
+        message: {
+            content: "message1",
+            refusal: null,
+            role: "assistant",
+        },
+        logprobs: null,
+    },
+    {
+        index: 0,
+        finish_reason: "stop",
+        message: {
+            content: "message2",
+            refusal: null,
+            role: "assistant",
+        },
+        logprobs: null,
+    },
+];
+function createCallTestToolScript(tool_call_ids, param1, param2) {
+    // A trivial tool
+    const parameters = {
+        type: "object",
+        properties: {
+            param1: {
+                type: "string",
+            },
+            param2: {
+                type: "number",
+            },
+        },
+        required: ["param1", "param2"],
+    };
+    const toolDescriptor = {
+        type: "function",
+        function: {
+            name: "test_tool",
+            parameters,
+            strict: true,
+        },
+    };
+    const toolFn = async (_, args) => {
+        const { param1, param2 } = args;
+        return new Promise((r) => {
+            r({ response: `tool_result: '${param1}' '${String(param2)}'` });
+        });
+    };
+    // A script that uses the tool
+    const script = [
+        {
+            index: 0,
+            finish_reason: "tool_calls",
+            message: {
+                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",
+                    };
+                }),
+            },
+            logprobs: null,
+        },
+        {
+            index: 0,
+            finish_reason: "stop",
+            message: {
+                content: "message after tools calls.",
+                refusal: null,
+                role: "assistant",
+            },
+            logprobs: null,
+        },
+    ];
+    // Expected output
+    const expectAgentMessages = [
+        "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,
+        };
+    });
+    return {
+        script,
+        expectCompletions: script.map((s) => s.message),
+        expectAgentMessages,
+        expectToolResults,
+        toolDescriptor,
+        toolFn,
+    };
+}
+/// Return a dummy agent and a TestAgentEventHandler for tracking messages.
+async function createTestAgent(script) {
+    const agentProfile = {
+        model: "dummy:" + JSON.stringify(script),
+        system_prompt: "SYSTEM_PROMPT",
+        mcp_settings: {},
+    };
+    const eventHandler = new testTools_1.TestAgentEventHandler();
+    const skillManager = await sudoMcpServerManager_1.SkillManager.initialize((url, authResultP, displayName) => {
+        testTools_1.DUMMY_PLATFORM.openUrl(url, authResultP, displayName);
+    }, sudoMcpServerManager_1.LOCAL_SERVER_URL, "dummy_key", undefined);
+    const agent = agent_1.Agent.initializeWithLLM(eventHandler, new testTools_1.TestDummyLLM(script), new context_1.ContextManager(agentProfile.system_prompt, []), skillManager);
+    return { agent, skillManager, eventHandler };
+}
+describe("Agent", () => {
+    it("correctly calls custom tools", async function () {
+        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 { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
+        agent.addAgentTool(toolDescriptor, toolFn);
+        await agent.userMessageEx("user message 1");
+        (0, vitest_1.expect)(eventHandler.getAgentMessages()).eql(expectAgentMessages);
+        (0, vitest_1.expect)(eventHandler.getToolCallResults()).eql(expectToolResults);
+        // Check the ordering
+        const allExpect = [
+            script[0].message,
+            ...expectToolResults,
+            script[1].message,
+        ];
+        const all = eventHandler.getAll();
+        (0, vitest_1.expect)(all).eql(allExpect);
+        const allToolCalls = eventHandler.getToolCalls();
+        const agentToolCalls = eventHandler.getAgentToolCalls();
+        const expectToolCalls = script[0].message.tool_calls;
+        (0, vitest_1.expect)(allToolCalls).eql(expectToolCalls);
+        (0, vitest_1.expect)(agentToolCalls).eql(expectToolCalls);
+    });
+    it("correctly invokes tool providers", async function () {
+        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 { 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);
+                        r();
+                    });
+                });
+            },
+        };
+        await agent.addAgentToolProvider(toolProvider);
+        await agent.userMessageEx("user message 1");
+        (0, vitest_1.expect)(eventHandler.getCompletions()).eql(expectCompletions);
+        (0, vitest_1.expect)(eventHandler.getAgentMessages()).eql(expectAgentMessages);
+        (0, vitest_1.expect)(eventHandler.getToolCallResults()).eql(expectToolResults);
+    });
+    it("correctly reflects system prompt", async function () {
+        const llm = new testTools_1.TestDummyLLM(DUMMY_SCRIPT);
+        const contextManager = new context_1.ContextManager("agent_prompt", []);
+        const agent = agent_1.Agent.initializeWithLLM(new testTools_1.TestAgentEventHandler(), llm, contextManager);
+        promptProvider_1.SystemPromptProvider.setGlobalPrompt("global_prompt");
+        // NOTE: SystemPromptProvider/ContextManager is unit tested elsewhere so
+        // we assume it computes the correct prompt.  Here we check that this is
+        // reflected in the request to LLM.
+        // Check the prompt
+        await agent.userMessageEx("user message 1");
+        let lastRequest = llm.getLastRequest();
+        (0, assert_1.strict)(lastRequest);
+        (0, vitest_1.expect)(lastRequest[0].content).eql(contextManager.getLLMContext()[0].content);
+        (0, vitest_1.expect)(agent.getSystemPrompt()).eql("agent_prompt");
+        // Update and re-check the prompt
+        agent.setSystemPrompt("agent_prompt_2");
+        await agent.userMessageEx("user message 1");
+        lastRequest = llm.getLastRequest();
+        (0, assert_1.strict)(lastRequest);
+        (0, vitest_1.expect)(lastRequest[0].content).eql(contextManager.getLLMContext()[0].content);
+        (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 param1 = "asdf";
+        const param2 = 3;
+        const { script, expectToolResults, toolDescriptor, toolFn } = createCallTestToolScript(tool_call_ids, param1, param2);
+        const { agent /*, skillManager */, eventHandler } = await createTestAgent(script);
+        agent.addAgentTool(toolDescriptor, toolFn);
+        await agent.userMessageEx("user message 1");
+        // Check the event handler was called with all completions and tool
+        // results, in the correct order.
+        const allExpect = [
+            script[0].message,
+            ...expectToolResults,
+            script[1].message,
+        ];
+        const all = eventHandler.getAll();
+        (0, vitest_1.expect)(all).eql(allExpect);
+        // The conversation (context) messages (order and number) should also
+        // match this.
+        const conv = agent.getConversation();
+        (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 param1 = "asdf";
+        const param2 = 3;
+        const { script, expectToolResults, toolDescriptor, toolFn } = 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.
+        const scriptCopy = clone(script);
+        const transformArgs = (args) => {
+            return { param1: args.param1.toUpperCase(), param2: args.param2 + 100 };
+        };
+        const transformArgsStr = (argsStr) => {
+            const args = JSON.parse(argsStr);
+            return JSON.stringify(transformArgs(args));
+        };
+        const newToolFn = async (agent, args) => {
+            const result = await toolFn(agent, args);
+            result.overwriteArgs = JSON.stringify(transformArgs(args));
+            return result;
+        };
+        agent.addAgentTool(toolDescriptor, 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
+        // results, in the correct order.
+        const transformToolCall = (toolCall) => {
+            return {
+                ...toolCall,
+                function: {
+                    ...toolCall.function,
+                    arguments: transformArgsStr(toolCall.function.arguments),
+                },
+            };
+        };
+        (0, assert_1.strict)(scriptCopy[0].message.tool_calls);
+        const transformedFirstMsg = {
+            ...scriptCopy[0].message,
+            tool_calls: scriptCopy[0].message.tool_calls.map(transformToolCall),
+        };
+        const allExpect = [
+            transformedFirstMsg,
+            ...expectToolResults,
+            scriptCopy[1].message,
+        ];
+        const all = eventHandler.getAll();
+        const conv = agent.getConversation();
+        (0, vitest_1.expect)(all).eql(allExpect);
+        (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 param1 = "asdf";
+        const param2 = 3;
+        const { script, expectToolResults, toolDescriptor, toolFn } = 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.
+        const transformResult = (result) => {
+            return result.toUpperCase();
+        };
+        const newToolFn = async (agent, args) => {
+            const result = await toolFn(agent, args);
+            result.overwriteResponse = transformResult(result.response);
+            return result;
+        };
+        agent.addAgentTool(toolDescriptor, 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
+        // results as expected.
+        const expectToolCallResults = expectToolResults.map((tr) => {
+            (0, assert_1.strict)(typeof tr.content === "string");
+            return {
+                ...tr,
+                content: transformResult(tr.content),
+            };
+        });
+        const allExpect = [
+            script[0].message,
+            ...expectToolCallResults,
+            script[1].message,
+        ];
+        const all = eventHandler.getAll();
+        const conv = agent.getConversation();
+        (0, vitest_1.expect)(all).eql(allExpect);
+        (0, vitest_1.expect)(conv.slice(1)).eql(all);
+    });
+    it("correctly handles LLM errors", async function () {
+        const eventHandler = new testTools_1.TestAgentEventHandler();
+        const llm = new testTools_1.TestErrorLLM();
+        const ctxMgr = new context_1.ContextManager("SYSTEM_PROMPT", []);
+        const agent = agent_1.Agent.initializeWithLLM(eventHandler, llm, ctxMgr);
+        await (0, vitest_1.expect)(agent.userMessagesRaw([{ role: "user", content: "message" }])).rejects.toThrow();
+        // Check the Agent has not added the user messages.
+        (0, vitest_1.expect)(ctxMgr.getLLMContext().length).eql(1);
+    });
+});

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const approvalManager_1 = require("../chat/utils/approvalManager");
+(0, vitest_1.describe)("ApprovalManager", () => {
+    let approvalManager;
+    (0, vitest_1.beforeEach)(() => {
+        approvalManager = new approvalManager_1.ApprovalManager(100); // Shorter timeout for tests
+    });
+    (0, vitest_1.it)("generate unique ids", async () => {
+        const app0 = approvalManager.startApproval("testApproval");
+        const app1 = approvalManager.startApproval("testApproval");
+        (0, vitest_1.expect)(app0.id).not.toBe(app1.id);
+        // Clean up to prevent unhandled rejections - catch the shutdown promises
+        const promises = [
+            app0.resultP.catch(() => "cancelled"),
+            app1.resultP.catch(() => "cancelled"),
+        ];
+        approvalManager.shutdown();
+        await Promise.all(promises);
+    });
+    (0, vitest_1.it)("resultP rejects on timeout", { timeout: 200 }, async function () {
+        const { resultP } = approvalManager.startApproval("timeoutTest");
+        const result = await resultP.catch((e) => e);
+        (0, vitest_1.expect)(result).toBeInstanceOf(approvalManager_1.ApprovalTimeout);
+        // No cleanup needed - the timeout already resolved the promise
+    });
+    (0, vitest_1.it)("resolve promises (accept and reject)", async () => {
+        const { id, resultP } = approvalManager.startApproval("acceptRejectTest");
+        const resultPromise = resultP.catch(() => ({
+            approved: false,
+            auto_approve: false,
+        }));
+        approvalManager.approvalResult(id, true, false);
+        const result = await resultPromise;
+        (0, vitest_1.expect)(result.approved).toBe(true);
+        const { id: rejectId, resultP: rejectP } = approvalManager.startApproval("rejectTest");
+        const rejectResultPromise = rejectP.catch(() => ({
+            approved: true,
+            auto_approve: false,
+        }));
+        approvalManager.approvalResult(rejectId, false, false);
+        const rejectResult = await rejectResultPromise;
+        (0, vitest_1.expect)(rejectResult.approved).toBe(false);
+    });
+    (0, vitest_1.it)("shutdown with unresolved promises", async () => {
+        const { resultP } = approvalManager.startApproval("acceptRejectTest");
+        // Setup a promise that catches the expected shutdown cancellation
+        const shutdownPromise = resultP.catch((error) => {
+            (0, vitest_1.expect)(error.message).toBe("shutdown");
+            return "cancelled";
+        });
+        approvalManager.shutdown();
+        // Await the promise to handle the rejection properly
+        const result = await shutdownPromise;
+        (0, vitest_1.expect)(result).toBe("cancelled");
+    });
+});