@xalia/agent 0.5.8 → 0.6.0

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const sessionRegistry_1 = require("./sessionRegistry");
+const mockFactories_1 = require("./test-utils/mockFactories");
+// Mock the complex agent creation to avoid network calls
+const mockCreateAgentWithoutSkills = vitest_1.vi.hoisted(() => vitest_1.vi.fn());
+vitest_1.vi.mock("../../agent/agentUtils", () => ({
+    createAgentWithoutSkills: mockCreateAgentWithoutSkills,
+}));
+(0, vitest_1.describe)("SessionRegistry", () => {
+    let sessionRegistry;
+    let mockDatabase;
+    let mockUserConnectionManager;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        // Setup the mock to return array with agent and skill manager
+        mockCreateAgentWithoutSkills.mockResolvedValue([
+            {
+            /* mock agent */
+            },
+            {
+                getServerBriefs: vitest_1.vi.fn().mockReturnValue([]),
+                /* mock skill manager */
+            },
+        ]);
+        // Create mocks using factories
+        mockDatabase = (0, mockFactories_1.createMockDatabase)();
+        mockUserConnectionManager = (0, mockFactories_1.createMockUserConnectionManager)();
+        // Setup standard behaviors
+        (0, mockFactories_1.setupStandardMockBehaviors)({
+            database: mockDatabase,
+            userConnectionManager: mockUserConnectionManager,
+        });
+        // Create SessionRegistry instance
+        sessionRegistry = new sessionRegistry_1.SessionRegistry(mockDatabase.mock, mockUserConnectionManager.mock, "http://llm-api.test", "http://xmcp-api.test");
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)("Session Membership Tracking", () => {
+        (0, vitest_1.it)("should correctly track user-session mapping", () => {
+            // Arrange - Setup session state using public API
+            const sessionId1 = "session-1";
+            const sessionId2 = "session-2";
+            const userId1 = mockFactories_1.MOCK_USERS.owner.uuid;
+            const userId2 = mockFactories_1.MOCK_USERS.participant.uuid;
+            // Mock database for session validation
+            mockDatabase.spies.sessionGetById.mockImplementation((sessionId) => {
+                if (sessionId === sessionId1 || sessionId === sessionId2) {
+                    return Promise.resolve({
+                        session_uuid: sessionId,
+                        title: `Test Session`,
+                        agent_profile_uuid: "agent-profile-1",
+                        owner_uuid: userId1,
+                        updated_at: "2025-01-01T00:00:00Z",
+                    });
+                }
+                return Promise.resolve(null);
+            });
+            // Create mock sessions in openSessions map
+            const mockSession1 = (0, mockFactories_1.createMockOpenSession)(sessionId1);
+            const mockSession2 = (0, mockFactories_1.createMockOpenSession)(sessionId2);
+            mockSession1.spies.getSessionState.mockReturnValue([]);
+            mockSession2.spies.getSessionState.mockReturnValue([]);
+            // Use bracket notation to access private property for testing
+            const registryWithSessions = sessionRegistry;
+            registryWithSessions.openSessions.set(sessionId1, mockSession1.mock);
+            registryWithSessions.openSessions.set(sessionId2, mockSession2.mock);
+            const registryWithPrivate = sessionRegistry;
+            registryWithPrivate.addUserToSessionMemory(userId1, sessionId1);
+            registryWithPrivate.addUserToSessionMemory(userId2, sessionId1);
+            registryWithPrivate.addUserToSessionMemory(userId1, sessionId2);
+            // Assert - Test getUserSessions for both users
+            const user1Sessions = sessionRegistry.getUserSessions(userId1);
+            (0, vitest_1.expect)(user1Sessions).toEqual(new Set([sessionId1, sessionId2]));
+            const user2Sessions = sessionRegistry.getUserSessions(userId2);
+            (0, vitest_1.expect)(user2Sessions).toEqual(new Set([sessionId1]));
+            // Assert - Test getInMemorySessionUsers for both sessions
+            const session1Users = sessionRegistry.getInMemorySessionUsers(sessionId1);
+            (0, vitest_1.expect)(session1Users).toEqual(new Set([userId1, userId2]));
+            (0, vitest_1.expect)(session1Users.size).toBe(2);
+            const session2Users = sessionRegistry.getInMemorySessionUsers(sessionId2);
+            (0, vitest_1.expect)(session2Users).toEqual(new Set([userId1]));
+            (0, vitest_1.expect)(session2Users.size).toBe(1);
+        });
+        (0, vitest_1.it)("should return empty sets for non-existent sessions or users", () => {
+            // Act & Assert - Test methods with non-existent data
+            const nonExistentSessionUsers = sessionRegistry.getInMemorySessionUsers("non-existent-session");
+            (0, vitest_1.expect)(nonExistentSessionUsers).toEqual(new Set());
+            (0, vitest_1.expect)(nonExistentSessionUsers.size).toBe(0);
+            const nonExistentUserSessions = sessionRegistry.getUserSessions("non-existent-user");
+            (0, vitest_1.expect)(nonExistentUserSessions).toEqual(new Set());
+            (0, vitest_1.expect)(nonExistentUserSessions.size).toBe(0);
+        });
+    });
+});

package/dist/agent/src/chat/server/test-utils/mockFactories.js

@@ -0,0 +1,307 @@
+"use strict";
+/**
+ * Common mock factories for chat server tests
+ * Provides consistent mock objects across all test suites
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOCK_AGENT_PROFILES = exports.MOCK_SESSIONS = exports.MOCK_USERS = void 0;
+exports.createMockDatabase = createMockDatabase;
+exports.createMockUserConnectionManager = createMockUserConnectionManager;
+exports.createMockSessionRegistry = createMockSessionRegistry;
+exports.createMockApiKeyManager = createMockApiKeyManager;
+exports.createMockWebSocket = createMockWebSocket;
+exports.createMockOpenSession = createMockOpenSession;
+exports.createMockSessionList = createMockSessionList;
+exports.setupStandardMockBehaviors = setupStandardMockBehaviors;
+const vitest_1 = require("vitest");
+// =====================================
+// Mock Data Constants
+// =====================================
+exports.MOCK_USERS = {
+    owner: {
+        uuid: "user-123",
+        nickname: "test-owner",
+    },
+    participant: {
+        uuid: "user-456",
+        nickname: "test-participant",
+    },
+    nonExistent: {
+        uuid: "user-999",
+        nickname: "non-existent",
+    },
+};
+exports.MOCK_SESSIONS = {
+    active: {
+        uuid: "session-abc",
+        title: "Test Session",
+        user_uuid: exports.MOCK_USERS.owner.uuid,
+        agent_profile_uuid: "agent-profile-1",
+        workspace: null,
+        team_uuid: null,
+        public: false,
+        updated_at: "2025-01-01T00:00:00Z",
+    },
+    secondary: {
+        uuid: "session-xyz",
+        title: "Secondary Session",
+        user_uuid: exports.MOCK_USERS.owner.uuid,
+        agent_profile_uuid: "agent-profile-2",
+        workspace: null,
+        team_uuid: null,
+        public: false,
+        updated_at: "2025-01-01T01:00:00Z",
+    },
+};
+exports.MOCK_AGENT_PROFILES = {
+    default: {
+        system_prompt: "You are a helpful assistant",
+        model: "gpt-4",
+        mcp_settings: {},
+    },
+    custom: {
+        system_prompt: "You are a specialized assistant",
+        model: "claude-3",
+        mcp_settings: {
+            filesystem: ["read_file", "write_file"],
+        },
+    },
+};
+// =====================================
+// Mock Factory Functions
+// =====================================
+/**
+ * Creates a mock Database instance with common methods
+ */
+function createMockDatabase() {
+    const spies = {
+        sessionCreate: vitest_1.vi.fn(),
+        sessionGetById: vitest_1.vi.fn(),
+        getUserFromUuid: vitest_1.vi.fn(),
+        getAgentProfileById: vitest_1.vi.fn(),
+        getSavedAgentProfileById: vitest_1.vi.fn(),
+        getUserApiKey: vitest_1.vi.fn(),
+        sessionParticipantAdd: vitest_1.vi.fn(),
+        sessionParticipantRemove: vitest_1.vi.fn(),
+        updateAgentProfile: vitest_1.vi.fn(),
+        sessionConversationAppend: vitest_1.vi.fn(),
+        sessionGetParticipants: vitest_1.vi.fn(),
+        getUserSessions: vitest_1.vi.fn(),
+    };
+    const mock = {
+        ...spies,
+        // Add any other Database methods that might be called
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a mock IUserConnectionManager instance
+ */
+function createMockUserConnectionManager() {
+    const spies = {
+        sendToUsers: vitest_1.vi.fn(),
+        sendToConnection: vitest_1.vi.fn(),
+        sendServerError: vitest_1.vi.fn(),
+        getLiveUserApiKey: vitest_1.vi.fn(),
+    };
+    const mock = {
+        sendToUsers: spies.sendToUsers,
+        sendToConnection: spies.sendToConnection,
+        sendServerError: spies.sendServerError,
+        getLiveUserApiKey: spies.getLiveUserApiKey,
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a mock IMessageProcessor instance
+ */
+function createMockSessionRegistry() {
+    const spies = {
+        processMessage: vitest_1.vi.fn(),
+        handleUserDisconnect: vitest_1.vi.fn(),
+    };
+    const mock = {
+        processMessage: spies.processMessage,
+        handleUserDisconnect: spies.handleUserDisconnect,
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a mock ApiKeyManager instance
+ */
+function createMockApiKeyManager() {
+    const spies = {
+        verifyApiKey: vitest_1.vi.fn(),
+    };
+    const mock = {
+        ...spies,
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a mock WebSocket instance
+ */
+function createMockWebSocket(readyState = 1) {
+    const spies = {
+        on: vitest_1.vi.fn(),
+        once: vitest_1.vi.fn(),
+        send: vitest_1.vi.fn(),
+        close: vitest_1.vi.fn(),
+    };
+    const mock = {
+        ...spies,
+        readyState, // Allow setting initial readyState
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a mock OpenSession instance
+ */
+function createMockOpenSession(sessionId = exports.MOCK_SESSIONS.active.uuid) {
+    const spies = {
+        addParticipant: vitest_1.vi.fn(),
+        leave: vitest_1.vi.fn(),
+        onClientMessage: vitest_1.vi.fn(),
+        getSessionState: vitest_1.vi.fn(),
+        broadcast: vitest_1.vi.fn(),
+        sendTo: vitest_1.vi.fn(),
+        onEmpty: vitest_1.vi.fn(),
+    };
+    const mock = {
+        ...spies,
+        sessionUUID: sessionId,
+        users: new Set(),
+        agentProfileUUID: exports.MOCK_SESSIONS.active.agent_profile_uuid,
+        sessionOwnerUserUUID: exports.MOCK_USERS.owner.uuid,
+    };
+    return { mock, spies };
+}
+/**
+ * Creates a standard set of session list items for testing
+ */
+function createMockSessionList() {
+    return [
+        {
+            session_uuid: exports.MOCK_SESSIONS.active.uuid,
+            title: exports.MOCK_SESSIONS.active.title,
+            team_uuid: undefined,
+            agent_profile_uuid: exports.MOCK_SESSIONS.active.agent_profile_uuid,
+            workspace: undefined,
+            updated_at: exports.MOCK_SESSIONS.active.updated_at || "",
+            user_uuid: exports.MOCK_SESSIONS.active.user_uuid,
+        },
+        {
+            session_uuid: exports.MOCK_SESSIONS.secondary.uuid,
+            title: exports.MOCK_SESSIONS.secondary.title,
+            team_uuid: undefined,
+            agent_profile_uuid: exports.MOCK_SESSIONS.secondary.agent_profile_uuid,
+            workspace: undefined,
+            updated_at: exports.MOCK_SESSIONS.secondary.updated_at || "",
+            user_uuid: exports.MOCK_SESSIONS.secondary.user_uuid,
+        },
+    ];
+}
+/**
+ * Helper to setup common mock behaviors
+ */
+function setupStandardMockBehaviors(mocks) {
+    // Setup database mocks
+    if (mocks.database) {
+        mocks.database.spies.getUserFromUuid.mockImplementation((userId) => {
+            if (userId === exports.MOCK_USERS.owner.uuid)
+                return Promise.resolve(exports.MOCK_USERS.owner);
+            if (userId === exports.MOCK_USERS.participant.uuid)
+                return Promise.resolve(exports.MOCK_USERS.participant);
+            return Promise.resolve(null);
+        });
+        mocks.database.spies.sessionGetById.mockImplementation((sessionId) => {
+            if (sessionId === exports.MOCK_SESSIONS.active.uuid)
+                return Promise.resolve(exports.MOCK_SESSIONS.active);
+            if (sessionId === exports.MOCK_SESSIONS.secondary.uuid)
+                return Promise.resolve(exports.MOCK_SESSIONS.secondary);
+            if (sessionId === "new-session-uuid")
+                return Promise.resolve({
+                    ...exports.MOCK_SESSIONS.active,
+                    uuid: "new-session-uuid",
+                });
+            return Promise.resolve(null);
+        });
+        mocks.database.spies.getAgentProfileById.mockImplementation((profileId) => {
+            if (profileId === "agent-profile-1")
+                return Promise.resolve(exports.MOCK_AGENT_PROFILES.default);
+            if (profileId === "agent-profile-2")
+                return Promise.resolve(exports.MOCK_AGENT_PROFILES.custom);
+            return Promise.resolve(null);
+        });
+        mocks.database.spies.getSavedAgentProfileById.mockImplementation((profileId) => {
+            if (profileId === "agent-profile-1") {
+                return Promise.resolve({
+                    uuid: "agent-profile-1",
+                    user_uuid: exports.MOCK_USERS.owner.uuid,
+                    profile_name: "Default Profile",
+                    profile: exports.MOCK_AGENT_PROFILES.default,
+                    preferences: { auto_approve: {} },
+                });
+            }
+            if (profileId === "agent-profile-2") {
+                return Promise.resolve({
+                    uuid: "agent-profile-2",
+                    user_uuid: exports.MOCK_USERS.owner.uuid,
+                    profile_name: "Custom Profile",
+                    profile: exports.MOCK_AGENT_PROFILES.custom,
+                    preferences: { auto_approve: {} },
+                });
+            }
+            return Promise.resolve(null);
+        });
+        mocks.database.spies.getUserApiKey.mockImplementation((userId) => {
+            if (userId === exports.MOCK_USERS.owner.uuid) {
+                return Promise.resolve("valid-api-key");
+            }
+            if (userId === exports.MOCK_USERS.participant.uuid) {
+                return Promise.resolve("participant-api-key");
+            }
+            return Promise.resolve(undefined);
+        });
+        mocks.database.spies.sessionCreate.mockImplementation(() => Promise.resolve());
+        mocks.database.spies.sessionParticipantAdd.mockImplementation(() => Promise.resolve());
+        mocks.database.spies.sessionParticipantRemove.mockImplementation(() => Promise.resolve());
+        // Setup sessionGetParticipants to return participants based on session
+        mocks.database.spies.sessionGetParticipants.mockImplementation((sessionId) => {
+            if (sessionId === exports.MOCK_SESSIONS.active.uuid) {
+                return Promise.resolve([
+                    { user_uuid: exports.MOCK_USERS.owner.uuid, role: "owner" },
+                    { user_uuid: exports.MOCK_USERS.participant.uuid, role: "participant" },
+                ]);
+            }
+            if (sessionId === exports.MOCK_SESSIONS.secondary.uuid) {
+                return Promise.resolve([
+                    { user_uuid: exports.MOCK_USERS.owner.uuid, role: "owner" },
+                ]);
+            }
+            return Promise.resolve([]);
+        });
+        // Setup getUserSessions to return empty array by default
+        mocks.database.spies.getUserSessions.mockImplementation(() => Promise.resolve([]));
+    }
+    // Setup API key manager mocks
+    if (mocks.apiKeyManager) {
+        mocks.apiKeyManager.spies.verifyApiKey.mockImplementation((apiKey) => {
+            if (apiKey === "valid-api-key")
+                return Promise.resolve(exports.MOCK_USERS.owner);
+            if (apiKey === "participant-api-key")
+                return Promise.resolve(exports.MOCK_USERS.participant);
+            return Promise.resolve(null);
+        });
+    }
+    // Setup user connection manager mocks
+    if (mocks.userConnectionManager) {
+        mocks.userConnectionManager.spies.getLiveUserApiKey.mockImplementation((userId) => {
+            if (userId === exports.MOCK_USERS.owner.uuid)
+                return "valid-api-key";
+            if (userId === exports.MOCK_USERS.participant.uuid)
+                return "participant-api-key";
+            return undefined;
+        });
+    }
+}

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

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Collection of simple Agent tools.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatorTool = void 0;
+exports.makeParseArgsFn = makeParseArgsFn;
+exports.isoWithTimezone = isoWithTimezone;
+exports.datetimeTool = datetimeTool;
+exports.calculatorEval = calculatorEval;
+exports.renderTool = renderTool;
+exports.webSearchTool = webSearchTool;
+exports.openURL = openURL;
+exports.openURLTool = openURLTool;
+exports.addDefaultChatTools = addDefaultChatTools;
+const expr_eval_1 = require("expr-eval");
+const htmlToText_1 = require("../utils/htmlToText");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const search_1 = require("../utils/search");
+const logger = (0, sdk_1.getLogger)();
+/**
+ * Returns a function which parses an `args` struct and attempts to extract
+ * multiple string parameters with the given names.  e.g.
+ *
+ *   const parseFn = makeParseArgsFn(["arg0", "arg1"] as const)
+ *
+ * creates `parseFn: (args: unknown) => { arg0: string, arg1: string }` which
+ * can be used to parse tool arguments.
+ *
+ * NOTE, the complex type parameters ensures that the name list is a
+ * compile-time value, which in turn ensures that the return value of this
+ * function is well-typed.
+ */
+function makeParseArgsFn(names) {
+    return (args) => {
+        if (typeof args !== "object") {
+            throw new Error(`invalid args: ${typeof args}`);
+        }
+        const argsObj = args;
+        for (const name of names) {
+            const val = argsObj[name];
+            if (typeof val !== "string") {
+                throw new Error(`invalid expr args.${name}: ${typeof val}`);
+            }
+        }
+        return argsObj;
+    };
+}
+const DATETIME_DESC = {
+    type: "function",
+    function: {
+        name: "time_now",
+        description: "Current time",
+    },
+};
+function isoWithTimezone(timeZone) {
+    return (new Intl.DateTimeFormat("sv-SE", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        timeZoneName: "short",
+    })
+        .format(new Date())
+        .replace(" ", "T") + ` (${timeZone})`);
+}
+function datetimeTool(timezone) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    const toolFn = async () => {
+        return { response: isoWithTimezone(timezone) };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(DATETIME_DESC, toolFn);
+        },
+    };
+}
+const ARITHMETIC_DESC = {
+    type: "function",
+    function: {
+        name: "arithmetic",
+        description: "Evaluate arithmetic expression",
+        parameters: {
+            type: "object",
+            properties: {
+                expr: {
+                    type: "string",
+                    description: "Expression containing +-*/()",
+                },
+            },
+            required: ["expr"],
+        },
+    },
+};
+function calculatorEval(args) {
+    try {
+        return String(expr_eval_1.Parser.evaluate(args));
+    }
+    catch (e) {
+        if (typeof e.message === "string") {
+            return e.message;
+        }
+        return String(e);
+    }
+}
+exports.calculatorTool = {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    setup: async (agent) => {
+        const getExpr = makeParseArgsFn(["expr"]);
+        // eslint-disable-next-line @typescript-eslint/require-await
+        const toolFn = async (_, args) => {
+            const { expr } = getExpr(args);
+            return { response: calculatorEval(expr) };
+        };
+        agent.addAgentTool(ARITHMETIC_DESC, toolFn);
+    },
+};
+const RENDER_DESC = {
+    type: "function",
+    function: {
+        name: "render",
+        description: "Display the given html fragment inside a div element",
+        parameters: {
+            type: "object",
+            properties: {
+                html: {
+                    type: "string",
+                    description: "HTML fragment to render",
+                },
+            },
+            required: ["html"],
+        },
+    },
+};
+function renderTool(platform) {
+    const getHtml = makeParseArgsFn(["html"]);
+    const toolFn = async (_, args) => {
+        const { html } = getHtml(args);
+        await platform.renderHTML(html);
+        return { response: "" };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(RENDER_DESC, toolFn);
+        },
+    };
+}
+const WEB_SEARCH_DESC = {
+    type: "function",
+    function: {
+        name: "web_search",
+        description: "Web search",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query text",
+                },
+            },
+            required: ["query"],
+        },
+    },
+};
+function webSearchTool() {
+    const getQuery = makeParseArgsFn(["query"]);
+    const toolFn = async (_, args) => {
+        const { query } = getQuery(args);
+        logger.debug(`[web_search]: query: ${query}`);
+        const results = await (0, search_1.webSearch)(query);
+        logger.debug(`[web_search]: results: ${results}`);
+        return { response: JSON.stringify(results) };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(WEB_SEARCH_DESC, toolFn);
+        },
+    };
+}
+// open_url
+/**
+ * For now, this matches the duckduckgo-mcp-server length.  Could extend
+ * depending on the application / model etc.
+ */
+const _OPEN_URL_MAX_LENGTH_STR = process.env["OPEN_URL_MAX_LENGTH"] || "8000";
+const OPEN_URL_MAX_LENGTH = parseInt(_OPEN_URL_MAX_LENGTH_STR, 10);
+const OPEN_URL_DESC = {
+    type: "function",
+    function: {
+        name: "open_url",
+        description: "Download content from a URL",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to download",
+                },
+            },
+            required: ["url"],
+        },
+    },
+};
+async function openURL(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        const status = String(response.status);
+        const code = response.statusText;
+        throw new Error(`Failed to fetch ${url}: ${status} ${code}`);
+    }
+    const html = await response.text();
+    return (0, htmlToText_1.htmlToText)(html, OPEN_URL_MAX_LENGTH);
+}
+function openURLTool() {
+    const getURL = makeParseArgsFn(["url"]);
+    const toolFn = async (_, args) => {
+        const { url } = getURL(args);
+        return { response: await openURL(url) };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(OPEN_URL_DESC, toolFn);
+        },
+    };
+}
+/**
+ * Add a set of agent tools for chat sessions.
+ */
+async function addDefaultChatTools(agent, timezone, platform) {
+    await agent.addAgentToolProvider(datetimeTool(timezone));
+    await agent.addAgentToolProvider(exports.calculatorTool);
+    await agent.addAgentToolProvider(renderTool(platform));
+    await agent.addAgentToolProvider(webSearchTool());
+    await agent.addAgentToolProvider(openURLTool());
+}