@xalia/agent 0.6.1 → 0.6.3

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionRegistry = void 0;
-exports.userSessionDataCreate = userSessionDataCreate;
-exports.teamSessionDataCreate = teamSessionDataCreate;
+exports.userSessionCreateData = userSessionCreateData;
+exports.teamSessionCreateData = teamSessionCreateData;
 const uuid_1 = require("uuid");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const messages_1 = require("../protocol/messages");
@@ -10,8 +10,8 @@ const openSession_1 = require("./openSession");
 const database_1 = require("../data/database");
 const userResolver_1 = require("../utils/userResolver");
 const errors_1 = require("../protocol/errors");
-const agentUtils_1 = require("../../agent/agentUtils");
 const errorUtils_1 = require("./errorUtils");
+const apiKeyManager_1 = require("../data/apiKeyManager");
 const logger = (0, sdk_1.getLogger)();
 class SessionRegistry {
     constructor(db, connectionManager, llmUrl, xmcpUrl) {
@@ -29,6 +29,8 @@ class SessionRegistry {
         // Session instances
         // sessionId -> OpenSession
         this.openSessions = new Map();
+        this.guests = new Map();
+        this.apiKeyManager = new apiKeyManager_1.ApiKeyManager(db);
     }
     /**
      * Add user to session membership.
@@ -112,6 +114,47 @@ class SessionRegistry {
     getInMemoryUserSessions(userId) {
         return this.userSessions.get(userId) || new Set();
     }
+    // IMessageProcessor<ClientToServer>
+    async authenticate(token) {
+        // Parse the api key to determine the type of connection
+        const { prefix, apiKey, payload: sessionUUID, } = apiKeyManager_1.ApiKeyManager.parseToken(token);
+        if (prefix === openSession_1.GUEST_TOKEN_PREFIX) {
+            if (!sessionUUID) {
+                throw new Error(`invalid token ${token}`);
+            }
+            const descriptor = await this.getSessionDescriptor(sessionUUID);
+            if (!descriptor) {
+                throw new Error(`no such session ${sessionUUID}`);
+            }
+            if (descriptor.access_token !== token) {
+                throw new Error(`invalid guest key ${apiKey}`);
+            }
+            // For now, add a new user to the DB (so simplify the process of adding
+            // users).
+            const user_uuid = (0, uuid_1.v4)();
+            const email = `${user_uuid}@`;
+            const nickname = "Guest";
+            const timezone = "UTC";
+            await this.db.createUser(user_uuid, email, nickname, timezone);
+            const user = {
+                uuid: user_uuid,
+                nickname: "Guest",
+                email: "guest",
+                timezone: "UTC",
+                guest_for_session: sessionUUID,
+            };
+            this.guests.set(user_uuid, user);
+            return user.uuid;
+            // throw new Error("unimpl");
+            // // return "";
+        }
+        const userData = await this.apiKeyManager.verifyApiKey(apiKey);
+        if (!userData) {
+            throw new errors_1.ChatFatalError("invalid api key");
+        }
+        return userData.uuid;
+    }
+    // IMessageProcessor<ClientToServer>
     async processMessage(connectionId, userId, message) {
         if ((0, messages_1.isClientControlMessage)(message)) {
             // handle connection level message
@@ -134,11 +177,11 @@ class SessionRegistry {
     async processClientControlMessage(connectionId, userId, message) {
         switch (message.type) {
             case "control_agent_profile_create":
-                await this.handleAgentProfileCreate(message, userId);
+                await this.handleAgentProfileCreate(userId, message);
                 break;
             case "control_agent_profile_delete":
-                // TODO:
-                throw new Error("not implemented yet");
+                await this.handleAgentProfileDelete(userId, message);
+                break;
             case "control_get_session_list":
                 await this.handleGetSessionList(connectionId, userId, message);
                 break;
@@ -173,6 +216,14 @@ class SessionRegistry {
     async handleGetSessionList(connectionId, userId, message) {
         try {
             const [userSessions, teamSessions, userAgents] = await this.getAllAgentsAndSessionsByUser(userId);
+            // Mark any guest session as a user session
+            const guest = this.guests.get(userId);
+            if (guest) {
+                const guestSession = await this.db.sessionGetDescriptorById(guest.guest_for_session);
+                if (guestSession) {
+                    userSessions.push(guestSession);
+                }
+            }
             const response = {
                 type: "control_session_list",
                 user_sessions: userSessions,
@@ -196,11 +247,11 @@ class SessionRegistry {
             // validate the session access
             await this.validateSessionAccess(sessionId, userId, "owner");
             // get users/team-uuid before deletion
-            const [users, teamUuid, sessionData] = await Promise.all([
+            const [users, sessionData] = await Promise.all([
                 this.getSessionUsers(sessionId),
-                this.db.sessionGetTeamUuid(sessionId),
-                this.db.sessionGetById(sessionId),
+                this.db.sessionGetDescriptorById(sessionId),
             ]);
+            const teamUuid = sessionData?.team_uuid;
             if (!sessionData) {
                 throw new errors_1.ChatFatalError(`No such session: ${sessionId}`);
             }
@@ -244,9 +295,10 @@ class SessionRegistry {
             const failedLookups = [];
             const validMemberIds = [];
             const participants = [];
-            // filter out the owner and extract failed lookups
+            // No need to filter out the owner here, that is done in
+            // `createTeamWithParticipants`
             resolvedMemberIds.forEach((user, index) => {
-                if (user && user.uuid !== userId) {
+                if (user) {
                     validMemberIds.push(user.uuid);
                     participants.push({
                         user_uuid: user.uuid,
@@ -255,23 +307,44 @@ class SessionRegistry {
                         role: "participant",
                     });
                 }
-                else if (user === undefined) {
+                else {
                     failedLookups.push(message.initial_members[index]);
                 }
             });
             // Create the team with initial participants
             const teamUuid = await this.db.createTeamWithParticipants(message.team_name, userId, validMemberIds);
+            // Create a default agent for the new team
+            const defaultAgentProfile = await this.db.createAgentProfile(undefined, teamUuid, sdk_1.DEFAULT_AGENT_PROFILE_NAME, sdk_1.DEFAULT_AGENT_PROFILE);
+            if (!defaultAgentProfile) {
+                throw new Error(`Failed to create default agent profile for team ${teamUuid}`);
+            }
+            // Get owner's information and add to participants for the response
+            const ownerInfo = await this.db.getUserFromUuid(userId);
+            if (!ownerInfo) {
+                throw new Error(`Cannot find owner user data for user ${userId}`);
+            }
+            const ownerParticipant = {
+                user_uuid: userId,
+                nickname: ownerInfo.nickname || "",
+                email: ownerInfo.email,
+                role: "owner",
+            };
             const response = {
                 type: "control_team_created",
                 team_uuid: teamUuid,
                 team_owner_uuid: userId,
                 team_name: message.team_name,
-                members: participants,
+                members: [ownerParticipant, ...participants],
                 failed_lookups: failedLookups,
             };
             const members = new Set(validMemberIds);
             members.add(userId);
             this.connectionManager.sendToUsers(members, response);
+            // Broadcast the default agent profile to all team members
+            this.connectionManager.sendToUsers(members, {
+                type: "control_agent_profile_created",
+                profile: defaultAgentProfile,
+            });
         }
         catch (error) {
             logger.error(`[SessionRegistry] Error creating team: ${String(error)}`);
@@ -338,6 +411,13 @@ class SessionRegistry {
                 });
             }
         }
+        // Notify all team members about the updated member list
+        const updatedParticipants = await this.db.teamGetMembers(message.target_team_id);
+        this.connectionManager.sendToUsers(new Set(updatedParticipants.map((p) => p.user_uuid)), {
+            type: "control_team_members_updated",
+            team_uuid: message.target_team_id,
+            members: updatedParticipants,
+        });
         logger.info(`[SessionRegistry] User ${user.uuid}` +
             `added to team ${message.target_team_id}`);
     }
@@ -388,6 +468,13 @@ class SessionRegistry {
                 this.removeUserFromSessionMemory(user.uuid, sessionData.session_uuid);
             }
         }
+        // Notify all remaining team members about the updated member list
+        const updatedParticipants = await this.db.teamGetMembers(message.target_team_id);
+        this.connectionManager.sendToUsers(new Set(updatedParticipants.map((p) => p.user_uuid)), {
+            type: "control_team_members_updated",
+            team_uuid: message.target_team_id,
+            members: updatedParticipants,
+        });
         logger.info(`[SessionRegistry] User ${user.uuid} ` +
             `removed from team ${message.target_team_id}`);
     }
@@ -398,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 };
         }
     }
     /**
@@ -421,15 +509,25 @@ class SessionRegistry {
             // Validate session access permissions
             const access = await this.validateSessionAccess(sessionId, userId);
             if (!access) {
-                throw new errors_1.ChatFatalError(`User ${userId} is not authorized to ` + `join session ${sessionId}`);
+                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, {
+                    user_uuid: guest.uuid,
+                    nickname: guest.nickname || "Guest",
+                    email: guest.email,
+                    role: "participant",
+                });
+            }
             // To this point, there should be no error thrown.
             // Update in-memory session-user/user-session mappings
             this.addUserToSessionMemory(userId, sessionId);
@@ -438,14 +536,14 @@ 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)}`);
             this.sendControlError(connectionId, message.client_message_id, String(error));
         }
     }
-    async handleAgentProfileCreate(message, from) {
+    async handleAgentProfileCreate(userId, message) {
         // get agent profile from template
         let agentProfileFromTemplate = undefined;
         if (message.template_name) {
@@ -455,11 +553,8 @@ class SessionRegistry {
             }
             agentProfileFromTemplate = template.agent_profile;
         }
-        const newAgentProfile = agentProfileFromTemplate || {
-            model: agentUtils_1.DEFAULT_LLM_MODEL,
-            system_prompt: sdk_1.DEFAULT_AGENT_PROFILE_SYSTEM_PROMPT,
-            mcp_settings: {},
-        };
+        const newAgentProfile = agentProfileFromTemplate ||
+            new sdk_1.AgentProfile(sdk_1.DEFAULT_AGENT_PROFILE.model, sdk_1.DEFAULT_AGENT_PROFILE.system_prompt, sdk_1.DEFAULT_AGENT_PROFILE.mcp_settings);
         const team_uuid = message.team_uuid || undefined;
         if (team_uuid) {
             // TODO: should be able to reconstruct the full SavedAgentProfile in one
@@ -474,17 +569,49 @@ class SessionRegistry {
             return savedAgentProfile.uuid;
         }
         // User AgentProfile
-        const savedAgentProfile = await this.db.createAgentProfile(from, undefined, message.title, newAgentProfile);
+        const savedAgentProfile = await this.db.createAgentProfile(userId, undefined, message.title, newAgentProfile);
         if (!savedAgentProfile) {
             throw new Error("failed creating agent profile (createAgentProfile)");
         }
         // Send the new AgentProfile to the user
-        this.connectionManager.sendToUsers(new Set([from]), {
+        this.connectionManager.sendToUsers(new Set([userId]), {
             type: "control_agent_profile_created",
             profile: savedAgentProfile,
         });
         return savedAgentProfile.uuid;
     }
+    async handleAgentProfileDelete(userId, message) {
+        const agentProfileUuid = message.agent_profile_uuid;
+        // Get the agent profile to determine if it's a team or user profile
+        const agentProfile = await this.db.getSavedAgentProfileById(agentProfileUuid);
+        if (!agentProfile) {
+            throw new Error(`Agent profile ${agentProfileUuid} not found`);
+        }
+        // Validate team access: user must own the profile or be in the team
+        // TODO: Only allow the owner to delete the profile?
+        if (agentProfile.team_uuid) {
+            const hasAccess = await this.validateTeamAccess(agentProfile.team_uuid, userId);
+            if (!hasAccess) {
+                throw new Error(`User ${userId} is not authorized to delete this agent profile`);
+            }
+        }
+        // Delete the agent profile from database
+        await this.db.deleteAgentProfile(agentProfileUuid);
+        // Send confirmation to all relevant users
+        if (agentProfile.team_uuid) {
+            const participants = await this.db.teamGetMembers(agentProfile.team_uuid);
+            this.connectionManager.sendToUsers(new Set(participants.map((p) => p.user_uuid)), {
+                type: "control_agent_profile_deleted",
+                profile_uuid: agentProfileUuid,
+            });
+        }
+        else {
+            this.connectionManager.sendToUsers(new Set([userId]), {
+                type: "control_agent_profile_deleted",
+                profile_uuid: agentProfileUuid,
+            });
+        }
+    }
     /**
      * Create a new session for a user.
      * - create session in database (via `newSession`)
@@ -497,12 +624,12 @@ class SessionRegistry {
             if (!message.agent_profile_id) {
                 logger.info("[handleSessionCreate] creating new AgentProfile");
                 // Create AgentProfile and inform the client
-                message.agent_profile_id = await this.handleAgentProfileCreate({
+                message.agent_profile_id = await this.handleAgentProfileCreate(fromUserId, {
                     type: "control_agent_profile_create",
                     title: "New Agent " + (0, uuid_1.v4)(),
                     user_uuid: fromUserId,
                     team_uuid: message.team_id,
-                }, fromUserId);
+                });
             }
             // Create new session and get its instance
             const { openSession, sessionId } = message.team_id
@@ -513,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}`);
         }
@@ -531,7 +659,7 @@ class SessionRegistry {
         // validate the agent profile
         await this.validateSavedAgentProfile(agentProfileId);
         const newSessionData = {
-            ...userSessionDataCreate(ownerId, title, agentProfileId),
+            ...userSessionCreateData(ownerId, title, agentProfileId),
             updated_at: new Date().toISOString(),
         };
         const openSession = await openSession_1.OpenSession.initWithEmptySession(this.db, newSessionData, this.llmUrl, this.xmcpUrl, this.connectionManager);
@@ -542,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 = {
-            ...teamSessionDataCreate(teamId, fromUserId, title, agentProfileId),
+            ...teamSessionCreateData(teamId, participants, fromUserId, title, agentProfileId),
             updated_at: new Date().toISOString(),
         };
         // initialize the open session
@@ -589,8 +718,24 @@ class SessionRegistry {
      * Handle user disconnect - clean up from all sessions.
      * Called when a connection is closed to ensure proper cleanup.
      */
-    handleUserDisconnect(userId) {
+    async handleUserDisconnect(userId) {
         logger.info(`[SessionRegistry] Handling disconnect for user ${userId}`);
+        // If the user is a guest, remove his DB entry.
+        const guest = this.guests.get(userId);
+        if (guest) {
+            const session = this.openSessions.get(guest.guest_for_session);
+            if (session) {
+                session.removeParticipant(userId);
+            }
+            this.guests.delete(userId);
+            try {
+                logger.info(`[SessionRegistry.handleUserDisconnect] deleting user ${userId}`);
+                await this.db.deleteUser(userId);
+            }
+            catch (e) {
+                logger.warn(`error removing guest ${userId}: ${(0, errorUtils_1.getErrorString)(e)}`);
+            }
+        }
         // Get all sessions the user is in (copy to avoid concurrent modification)
         const userSessionIds = this.getInMemoryUserSessions(userId);
         const sessionsToLeave = Array.from(userSessionIds);
@@ -607,11 +752,12 @@ class SessionRegistry {
      * This will also create a default agent profile if none exists.
      */
     async getAllAgentsAndSessionsByUser(userId) {
-        return Promise.all([
+        const [userSessions, teamInfos, userAgents] = await Promise.all([
             this.db.getUserSessions(userId),
             this.db.getTeamInfosByUser(userId),
             this.agentProfilesGetByUserOrDefault(userId),
         ]);
+        return [userSessions, teamInfos, userAgents];
     }
     async agentProfilesGetByUserOrDefault(userId) {
         const agentProfiles = await this.db.agentProfilesGetByUser(userId);
@@ -645,6 +791,12 @@ class SessionRegistry {
             const participants = session.getParticipants();
             const role = participants.get(userId);
             if (!role) {
+                // Check for guest access
+                const guest = this.guests.get(userId);
+                if (guest && guest.guest_for_session === sessionId) {
+                    return !accessType || accessType === "participant";
+                }
+                // Not authorized to join the session
                 return false;
             }
             else {
@@ -656,6 +808,12 @@ class SessionRegistry {
             const participants = await this.db.sessionGetParticipants(sessionId);
             const role = participants.find((p) => p.user_uuid === userId)?.role;
             if (!role) {
+                // Check for guest access
+                const guest = this.guests.get(userId);
+                logger.info(`[validateSessionAccess] guest: ${JSON.stringify(guest)}`);
+                if (guest && guest.guest_for_session === sessionId) {
+                    return !accessType || accessType === "participant";
+                }
                 return false;
             }
             else {
@@ -676,25 +834,39 @@ class SessionRegistry {
             return !accessType || role === accessType;
         }
     }
+    /**
+     * Read from DB if the session is not active
+     */
+    async getSessionDescriptor(sessionId) {
+        const session = this.openSessions.get(sessionId);
+        if (session) {
+            return session.getDescriptor();
+        }
+        else {
+            // fetch the session from database
+            return this.db.sessionGetDescriptorById(sessionId);
+        }
+    }
 }
 exports.SessionRegistry = SessionRegistry;
-function userSessionDataCreate(ownerId, title, agentProfileId) {
+function userSessionCreateData(ownerId, title, agentProfileId) {
     return {
         session_uuid: database_1.Database.sessionNewUUID(),
         title,
         team_uuid: undefined,
         agent_profile_uuid: agentProfileId,
-        workspace: undefined,
         user_uuid: ownerId,
+        agent_paused: false,
     };
 }
-function teamSessionDataCreate(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,
-        workspace: undefined,
         user_uuid: ownerId,
+        agent_paused: false,
     };
 }

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

@@ -102,13 +102,11 @@ function createMockUserConnectionManager() {
         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 };
 }
@@ -117,10 +115,18 @@ function createMockUserConnectionManager() {
  */
 function createMockSessionRegistry() {
     const spies = {
+        authenticate: vitest_1.vi.fn().mockImplementation((apiKey) => {
+            if (apiKey === "valid-api-key")
+                return Promise.resolve(exports.MOCK_USERS.owner.uuid);
+            if (apiKey === "participant-api-key")
+                return Promise.resolve(exports.MOCK_USERS.participant.uuid);
+            return Promise.resolve(null);
+        }),
         processMessage: vitest_1.vi.fn(),
         handleUserDisconnect: vitest_1.vi.fn(),
     };
     const mock = {
+        authenticate: spies.authenticate,
         processMessage: spies.processMessage,
         handleUserDisconnect: spies.handleUserDisconnect,
     };
@@ -189,6 +195,7 @@ function createMockSessionList() {
             workspace: undefined,
             updated_at: exports.MOCK_SESSIONS.active.updated_at || "",
             user_uuid: exports.MOCK_SESSIONS.active.user_uuid,
+            agent_paused: false,
         },
         {
             session_uuid: exports.MOCK_SESSIONS.secondary.uuid,
@@ -198,6 +205,7 @@ function createMockSessionList() {
             workspace: undefined,
             updated_at: exports.MOCK_SESSIONS.secondary.updated_at || "",
             user_uuid: exports.MOCK_SESSIONS.secondary.user_uuid,
+            agent_paused: false,
         },
     ];
 }
@@ -295,13 +303,6 @@ function setupStandardMockBehaviors(mocks) {
         });
     }
     // 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;
-        });
-    }
+    // if (mocks.userConnectionManager) {
+    // }
 }

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

@@ -17,23 +17,34 @@ 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 sessionFileManager_1 = require("./sessionFileManager");
+const imageGeneratorTools_1 = require("./imageGeneratorTools");
 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)
+ *   const parseFn = makeParseArgsFn(
+ *     ["arg0", "arg1"] as const,
+ *     ["opt0"] as const)
  *
- * creates `parseFn: (args: unknown) => { arg0: string, arg1: string }` which
- * can be used to parse tool arguments.
+ * creates
+ *
+ *   parseFn: (args: unknown) => {
+ *     arg0: string,
+ *     arg1: string,
+ *     opt0: string|undefined
+ *   }
+ *
+ * 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) {
+function makeParseArgsFn(names, optNames) {
     return (args) => {
-        if (typeof args !== "object") {
+        if (!args || typeof args !== "object") {
             throw new Error(`invalid args: ${typeof args}`);
         }
         const argsObj = args;
@@ -43,6 +54,14 @@ function makeParseArgsFn(names) {
                 throw new Error(`invalid expr args.${name}: ${typeof val}`);
             }
         }
+        if (optNames) {
+            for (const name of optNames) {
+                const val = argsObj[name];
+                if (typeof val !== "undefined" && typeof val !== "string") {
+                    throw new Error(`invalid expr args.${name}: ${typeof val}`);
+                }
+            }
+        }
         return argsObj;
     };
 }
@@ -234,10 +253,12 @@ function openURLTool() {
 /**
  * Add a set of agent tools for chat sessions.
  */
-async function addDefaultChatTools(agent, timezone, platform) {
+async function addDefaultChatTools(agent, timezone, platform, fileManager, llmUrl, llmApiKey) {
     await agent.addAgentToolProvider(datetimeTool(timezone));
     await agent.addAgentToolProvider(exports.calculatorTool);
     await agent.addAgentToolProvider(renderTool(platform));
     await agent.addAgentToolProvider(webSearchTool());
     await agent.addAgentToolProvider(openURLTool());
+    await agent.addAgentToolProvider((0, sessionFileManager_1.fileManagerTool)(fileManager));
+    await agent.addAgentToolProvider(await (0, imageGeneratorTools_1.genImageFileTool)(llmUrl, llmApiKey, fileManager));
 }