@xalia/agent 0.6.1 → 0.6.3

package/dist/agent/src/agent/openAILLMStreaming.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAILLMStreaming = void 0;
 exports.initializeCompletion = initializeCompletion;
 exports.updateCompletion = updateCompletion;
-const sdk_1 = require("@xalia/xmcp/sdk");
 const openai_1 = require("openai");
 const assert_1 = require("assert");
-const agentUtils_1 = require("./agentUtils");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const llm_1 = require("./llm");
 const logger = (0, sdk_1.getLogger)();
 function initialToolCallFunction(deltaFn) {
     //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
@@ -152,6 +152,14 @@ function initializeCompletionMessage(delta) {
         tool_calls: toolCalls,
     };
 }
+function updateReasoning(message, reasoning) {
+    if (!message.reasoning) {
+        message.reasoning = reasoning;
+    }
+    else {
+        message.reasoning += reasoning;
+    }
+}
 function updateCompletionMessage(message, delta) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     (0, assert_1.strict)(message.role === "assistant");
@@ -160,12 +168,20 @@ function updateCompletionMessage(message, delta) {
     (0, assert_1.strict)(!message.audio);
     (0, assert_1.strict)(message.tool_calls instanceof Array ||
         typeof message.tool_calls === "undefined");
-    //   export interface ChatCompletionChunk.Choice.Delta {
+    //   export interface ChatCompletionChunkChoiceDeltaWithReasoning {
     //     content?: string | null;
     //     function_call?: Delta.FunctionCall;
     //     refusal?: string | null;
     //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
     //     tool_calls?: Array<Delta.ToolCall>;
+    //
+    //     reasoning?: string;
+    //     reasoning_details?: {
+    //       type: "reasoning.text",
+    //       text?: string,
+    //       format?: string,
+    //       index?:0
+    //     }[]
     //   }
     //
     // ->
@@ -178,6 +194,8 @@ function updateCompletionMessage(message, delta) {
     //     audio?: ChatCompletionAudio | null;
     //     function_call?: ChatCompletionMessage.FunctionCall | null;
     //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //
+    //     reasoning?: string;
     //   }
     if (delta.content) {
         if (message.content) {
@@ -203,6 +221,10 @@ function updateCompletionMessage(message, delta) {
             message.tool_calls = updateToolCalls(message.tool_calls, t);
         }
     }
+    const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+    if (reasoning) {
+        updateReasoning(message, reasoning);
+    }
 }
 function initializeCompletionChoice(chunkChoice) {
     //   export interface ChatCompletionChunk.Choice {
@@ -377,9 +399,9 @@ class OpenAILLMStreaming {
             apiKey,
             baseURL: apiUrl,
             dangerouslyAllowBrowser: true,
-            defaultHeaders: agentUtils_1.XALIA_APP_HEADER,
+            defaultHeaders: llm_1.XALIA_APP_HEADER,
         });
-        this.model = model || agentUtils_1.DEFAULT_LLM_MODEL;
+        this.model = model;
     }
     setModel(model) {
         this.model = model;
@@ -390,7 +412,11 @@ class OpenAILLMStreaming {
     getUrl() {
         return this.openai.baseURL;
     }
-    async getConversationResponse(messages, tools, onMessage) {
+    async getConversationResponse(messages, tools, onMessage, onReasoning) {
+        const reasoning = {
+            effort: "medium",
+            enabled: true,
+        };
         const chunks = await this.openai.chat.completions.create({
             model: this.model,
             messages,
@@ -399,6 +425,7 @@ class OpenAILLMStreaming {
             stream_options: {
                 include_usage: true,
             },
+            extra_body: { reasoning },
         });
         // Check the type casting above
         if (!chunks.iterator) {
@@ -430,6 +457,14 @@ class OpenAILLMStreaming {
                     await onMessage(delta.content, false);
                 }
             }
+            if (onReasoning) {
+                const delta = chunk.choices[0]
+                    ?.delta;
+                const reasoning = (0, llm_1.choiceDeltaExtractReasoning)(delta);
+                if (reasoning) {
+                    await onReasoning(reasoning);
+                }
+            }
         }
         if (onMessage) {
             await onMessage("", true);

package/dist/agent/src/chat/client/chatClient.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatClient = void 0;
 const uuid_1 = require("uuid");
+const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const connection_1 = require("./connection");
 const sessionClient_1 = require("./sessionClient");
@@ -9,36 +10,31 @@ const database_1 = require("../data/database");
 const messages_1 = require("../protocol/messages");
 const constants_1 = require("./constants");
 const agentSessionMap_1 = require("../utils/agentSessionMap");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 const logger = (0, sdk_1.getLogger)();
+function idExtractor(msg) {
+    return msg.client_message_id;
+}
 class ChatClient {
-    constructor(connection, eventHandler, 
-    // agent_uuid -> agent session data
-    userAgentSessionMap = new Map(), 
-    // team_uuid -> team info
-    teams = new Map(), closed = false, currentSessionId = undefined, 
-    // note: currentTeamId will not be reset when swtiching to a user session.
-    currentTeamId = undefined, 
-    // session_uuid -> session client
-    activeSessions = new Map(), 
-    // session_uuid -> true if there is a new message.
-    newMessage = new Map(), 
-    // Track pending session join request, this should be a singleton
-    sessionJoinOrCreateRes = undefined) {
+    constructor(connection, eventHandler, userAgentSessionMap, teams, isGuestMode) {
         this.connection = connection;
         this.eventHandler = eventHandler;
         this.userAgentSessionMap = userAgentSessionMap;
         this.teams = teams;
-        this.closed = closed;
-        this.currentSessionId = currentSessionId;
-        this.currentTeamId = currentTeamId;
-        this.activeSessions = activeSessions;
-        this.newMessage = newMessage;
-        this.sessionJoinOrCreateRes = sessionJoinOrCreateRes;
+        this.isGuestMode = isGuestMode;
+        this.closed = false;
+        this.currentSessionId = undefined;
+        this.currentTeamId = undefined;
+        this.activeSessions = new Map();
+        this.newMessage = new Map();
+        this.sessionJoinAwaiter = responseAwaiter_1.ResponseAwaiter.initWithImmediate("control_error", idExtractor, this.onJoinCreateResponse.bind(this), Math.max(constants_1.SESSION_JOIN_TIMEOUT));
     }
     /**
      * Connect to server and create ChatClient instance
      */
     static async init(url, token, eventHandler) {
+        // Determine if this is a guest token (format: guest_<hash>_<session-id>)
+        const isGuestMode = token.startsWith("guest_");
         const connection = new connection_1.Connection({
             url,
             token,
@@ -69,7 +65,7 @@ class ChatClient {
                 });
                 if (!client) {
                     logger.info("Creating ChatClient");
-                    client = new ChatClient(connection, eventHandler, userAgentSessionMap, teams);
+                    client = new ChatClient(connection, eventHandler, userAgentSessionMap, teams, isGuestMode);
                     resolveClient(client);
                 }
                 else {
@@ -212,70 +208,26 @@ class ChatClient {
         this.teams.clear();
         this.currentSessionId = undefined;
         this.currentTeamId = undefined;
-        this.sessionJoinOrCreateRes = undefined;
     }
     async createNewSession(newTitle, agentProfileId, teamId) {
         if (this.closed) {
             throw new Error("ChatClient is closed");
         }
-        if (this.sessionJoinOrCreateRes) {
-            logger.error(`[ChatClient] creating new session with ` +
-                `profile id ${JSON.stringify(agentProfileId)}`);
-            throw new Error("Session join/create is already in progress");
-        }
-        return new Promise((resolve, reject) => {
-            const clientMessageId = (0, uuid_1.v4)();
-            // Set up timeout for the request
-            const timeoutId = setTimeout(() => {
-                this.sessionJoinOrCreateRes = undefined;
-                reject(new Error(`Session join timeout for creating new session`));
-            }, constants_1.SESSION_CREATE_TIMEOUT);
-            // Track this pending request
-            this.sessionJoinOrCreateRes = {
-                resolve: (sessionClient, sessionInfo) => {
-                    const sessionId = this.sessionJoinOrCreateRes?.sessionId;
-                    if (!sessionId) {
-                        throw new Error("Session id is not set in resolving.");
-                    }
-                    if (sessionId !== sessionInfo.session_id) {
-                        throw new Error("SessionInfo id mismatch");
-                    }
-                    clearTimeout(timeoutId);
-                    this.activeSessions.set(sessionId, sessionClient);
-                    this.currentSessionId = sessionId;
-                    if (sessionInfo.team_uuid) {
-                        this.currentTeamId = sessionInfo.team_uuid;
-                    }
-                    this.sessionJoinOrCreateRes = undefined;
-                    this.addSessionToAgentSessionMap(sessionInfo);
-                    resolve(sessionClient);
-                },
-                reject: (error) => {
-                    clearTimeout(timeoutId);
-                    this.sessionJoinOrCreateRes = undefined;
-                    reject(error);
-                },
-                sessionId: "",
-                clientMessageId,
-            };
-            // Send session_create message
-            try {
-                this.connection.send({
-                    type: "control_session_create",
-                    client_message_id: clientMessageId,
-                    title: newTitle,
-                    agent_profile_id: agentProfileId,
-                    team_id: teamId,
-                });
-                logger.info(`[ChatClient] Sent session_create for session ${newTitle}` +
-                    ` client message id: ${clientMessageId}`);
-            }
-            catch (error) {
-                this.sessionJoinOrCreateRes = undefined;
-                clearTimeout(timeoutId);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
+        const clientMessageId = (0, uuid_1.v4)();
+        const createdSessionP = this.sessionJoinAwaiter.waitForResponse(clientMessageId);
+        const createMsg = {
+            type: "control_session_create",
+            client_message_id: clientMessageId,
+            title: newTitle,
+            agent_profile_id: agentProfileId,
+            team_id: teamId,
+        };
+        this.connection.send(createMsg);
+        logger.info(`[ChatClient] Sent ${JSON.stringify(createMsg)}`);
+        const createdSession = await createdSessionP;
+        const sessionId = createdSession.client.getSessionUUID();
+        logger.info(`[ChatClient] joined session ${sessionId}`);
+        return createdSession.client;
     }
     /**
      * Connect to an existing session by sending session_join message
@@ -285,58 +237,22 @@ class ChatClient {
         if (this.closed) {
             throw new Error("ChatClient is closed");
         }
-        if (this.sessionJoinOrCreateRes) {
-            logger.error(`[ChatClient] connecting to session ${sessionId}`);
-            throw new Error("Session join/create is already in progress");
-        }
-        // TODO: we can directly return a session client if we cache conversation.
-        // For now, we go through the join process.
-        return new Promise((resolve, reject) => {
-            const clientMessageId = (0, uuid_1.v4)();
-            // Set up timeout for the request
-            const timeoutId = setTimeout(() => {
-                this.sessionJoinOrCreateRes = undefined;
-                reject(new Error(`Session join timeout for session ${sessionId}`));
-            }, constants_1.SESSION_JOIN_TIMEOUT);
-            // Track this pending request
-            this.sessionJoinOrCreateRes = {
-                resolve: (sessionClient, sessionInfo) => {
-                    clearTimeout(timeoutId);
-                    this.activeSessions.set(sessionId, sessionClient);
-                    this.currentSessionId = sessionId;
-                    if (sessionInfo.team_uuid) {
-                        this.currentTeamId = sessionInfo.team_uuid;
-                    }
-                    this.sessionJoinOrCreateRes = undefined;
-                    this.updateSessionInfo(sessionInfo);
-                    logger.info(`[ChatClient] joined session ${sessionId}`);
-                    resolve(sessionClient);
-                },
-                reject: (error) => {
-                    clearTimeout(timeoutId);
-                    this.sessionJoinOrCreateRes = undefined;
-                    logger.error(`[ChatClient] failed to join session` +
-                        ` ${sessionId}: ${error.message}`);
-                    reject(error);
-                },
-                sessionId,
-                clientMessageId,
-            };
-            // Send session_join message
-            try {
-                this.connection.send({
-                    type: "control_session_join",
-                    client_message_id: clientMessageId,
-                    target_session_id: sessionId,
-                });
-                logger.debug(`[ChatClient] Sent session_join for session ${sessionId}`);
-            }
-            catch (error) {
-                this.sessionJoinOrCreateRes = undefined;
-                clearTimeout(timeoutId);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
+        const clientMessageId = (0, uuid_1.v4)();
+        const createdSessionP = this.sessionJoinAwaiter.waitForResponse(clientMessageId);
+        this.connection.send({
+            type: "control_session_join",
+            client_message_id: clientMessageId,
+            target_session_id: sessionId,
         });
+        logger.debug(`[ChatClient] Sent session_join for session ${sessionId}`);
+        // Await the response
+        const createdSession = await createdSessionP;
+        const newSessionId = createdSession.client.getSessionUUID();
+        if (newSessionId !== sessionId) {
+            throw new Error(`unexpected session id ${newSessionId}`);
+        }
+        logger.info(`[ChatClient] joined session ${sessionId}`);
+        return createdSession.client;
     }
     /**
      * Fetch the session list from the server
@@ -364,6 +280,22 @@ class ChatClient {
         });
         logger.debug(`[ChatClient] Sent session_delete_request for` + ` session ${sessionId}`);
     }
+    /**
+     * Delete an agent profile by sending control_agent_profile_delete message
+     * @param agentProfileUuid - The UUID of the agent profile to delete
+     * @returns void
+     */
+    deleteAgentProfile(agentProfileUuid) {
+        if (this.closed) {
+            throw new Error("ChatClient is closed");
+        }
+        this.connection.send({
+            type: "control_agent_profile_delete",
+            agent_profile_uuid: agentProfileUuid,
+        });
+        logger.debug(`[ChatClient] Sent control_agent_profile_delete for profile ` +
+            agentProfileUuid);
+    }
     /**
      * Create a new team with initial members
      * @param teamName
@@ -513,6 +445,9 @@ class ChatClient {
             case "control_team_created":
                 this.handleTeamCreatedMessage(msg);
                 break;
+            case "control_team_members_updated":
+                this.handleTeamMembersUpdated(msg);
+                break;
             default: {
                 const _exhaustive = msg;
                 throw new Error(`unexpected control msg: ${JSON.stringify(msg)}`);
@@ -541,8 +476,29 @@ class ChatClient {
         }
         void this.eventHandler.onMessage(msg, this);
     }
-    handleAgentProfileDeleted(_msg) {
-        throw new Error("handleAgentProfileDeleted not implemented");
+    handleAgentProfileDeleted(msg) {
+        logger.debug(`[ChatClient.handleAgentProfileDeleted] msg: ${JSON.stringify(msg)}`);
+        const profileUuid = msg.profile_uuid;
+        let found = false;
+        // Try to remove from user agent session map
+        if (this.userAgentSessionMap.has(profileUuid)) {
+            this.userAgentSessionMap.delete(profileUuid);
+            found = true;
+        }
+        else {
+            // Try to remove from team agent session maps
+            for (const [_teamId, team] of this.teams.entries()) {
+                if (team.agentSessionMap.has(profileUuid)) {
+                    team.agentSessionMap.delete(profileUuid);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            logger.warn(`[ChatClient] Agent profile ${profileUuid} not found in any session map`);
+        }
+        void this.eventHandler.onMessage(msg, this);
     }
     handleSessionMessage(msg) {
         const sessionId = msg.session_id;
@@ -587,95 +543,52 @@ class ChatClient {
         void this.eventHandler.onMessage(msg, this);
         return;
     }
+    handleTeamMembersUpdated(msg) {
+        const team = this.teams.get(msg.team_uuid);
+        if (!team) {
+            logger.warn(`[ChatClient] Received team_members_updated for unknown team ` +
+                msg.team_uuid);
+            return;
+        }
+        // Update the participants map
+        team.participants = new Map(msg.members.map((participant) => [participant.user_uuid, participant]));
+        logger.info(`[ChatClient] Updated team members for team ${msg.team_uuid}, ` +
+            `now has ${String(msg.members.length)} members`);
+        void this.eventHandler.onMessage(msg, this);
+    }
     /**
      * Handle session_info message which can be for:
      * 1. A pending session join/create request
      * 2. An update to an existing active session
+     * 3. A new session notification
      * We update the session list here as well.
      */
     handleSessionInfoMessage(msg) {
-        const sessionId = msg.session_id;
-        // There is a pending request, check if this is the response
-        if (this.sessionJoinOrCreateRes &&
-            msg.client_message_id === this.sessionJoinOrCreateRes.clientMessageId) {
-            const { resolve, reject } = this.sessionJoinOrCreateRes;
-            try {
-                logger.info(`[ChatClient] Creating SessionClient for session ${sessionId}`);
-                logger.info(`[ChatClient] msg: ${JSON.stringify(msg)}`);
-                const sessionClient = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants));
-                // we need to pass the session id if this is a new session
-                if (this.sessionJoinOrCreateRes.sessionId === "") {
-                    this.sessionJoinOrCreateRes.sessionId = sessionId;
-                }
-                else if (this.sessionJoinOrCreateRes.sessionId !== sessionId) {
-                    throw new Error(`[ChatClient] session id mismatch: ` +
-                        `${this.sessionJoinOrCreateRes.sessionId} !== ${sessionId}`);
-                }
-                resolve(sessionClient, msg);
-            }
-            catch (error) {
-                const errorMsg = error instanceof Error ? error : new Error(String(error));
-                logger.error(`[ChatClient] Failed to create SessionClient: ${errorMsg.message}`);
-                reject(errorMsg);
-            }
-        }
-        else {
-            this.updateSessionInfo(msg);
+        // We intercept messages for th Awaiter here so that we can create and
+        // register the client immediately, before other messages for this session
+        // are handled.  Relying on Awaiter alone (currently) schedules the resolv
+        // to be called later (potentially AFTER further messages for the session
+        // have been received).
+        if (this.sessionJoinAwaiter.onMessage(msg)) {
+            return;
         }
+        logger.debug(`[ChatClient.handleSessionInfoMessage] not handled by awaiter - updating`);
+        this.upsertSessionToAgentSessionMap(msg);
     }
     handleControlError(msg) {
-        // reject the pending session join/create request if message id matches
-        if (this.sessionJoinOrCreateRes &&
-            msg.client_message_id === this.sessionJoinOrCreateRes.clientMessageId) {
-            this.sessionJoinOrCreateRes.reject(new Error(msg.message));
+        if (this.sessionJoinAwaiter.onMessage(msg)) {
+            return;
         }
         this.eventHandler.onError(`Server error: ${msg.message}`);
     }
-    /**
-     * Update the session list. This is called when a session is updated.
-     * An error is thrown if the session id is not found.
-     * TODO: we might want to resync session map, for now, throw error to
-     * expose problems in the code.
-     */
-    updateAgentSessionMap(sessionInfo) {
-        const sessionId = sessionInfo.session_id;
-        if (sessionInfo.team_uuid) {
-            const teamInfo = this.teams.get(sessionInfo.team_uuid);
-            if (!teamInfo) {
-                throw new Error(`Team ${sessionInfo.team_uuid} not found in team list`);
-            }
-            //teamInfo.sessions.set(sessionId, ChatClient.toSessionData(sessionInfo));
-            const agentSessionMap = teamInfo.agentSessionMap;
-            if (!doUpdateAgentSessionMap(agentSessionMap, sessionInfo)) {
-                throw new Error(`[updateAgentSessionMap] team session ${sessionId}` +
-                    ` not found in agent session map`);
-            }
-        }
-        else {
-            const agentSessionMap = this.userAgentSessionMap;
-            if (!doUpdateAgentSessionMap(agentSessionMap, sessionInfo)) {
-                throw new Error(`[updateAgentSessionMap] user session ${sessionId}` +
-                    ` not found in agent session map`);
-            }
-        }
-    }
-    /**
-     * Update the session info for an existing session. This passes the session
-     * info to the session client. An error is thrown if the session client is not
-     * found.
-     */
-    updateSessionInfo(msg) {
-        const sessionId = msg.session_id;
-        const sessionClient = this.activeSessions.get(sessionId);
-        this.updateAgentSessionMap(msg);
-        if (sessionClient) {
-            sessionClient.updateSessionInfo(msg);
-        }
-        else {
-            throw new Error(`Session client not found for session ${sessionId}`);
+    upsertSessionToAgentSessionMap(msg) {
+        // Skip agent session map updates for guest sessions since they don't
+        // need session organization
+        if (this.isGuestMode) {
+            logger.info(`[ChatClient] Skipping agent session map add for ` +
+                `guest session ${msg.session_id}`);
+            return;
         }
-    }
-    addSessionToAgentSessionMap(msg) {
         // get the correct agent session map
         const agentSessionMap = msg.team_uuid
             ? this.teams.get(msg.team_uuid)?.agentSessionMap
@@ -690,44 +603,50 @@ class ChatClient {
             throw new Error(`[addSessionToAgentSessionMap] Agent ${agentUuid}` +
                 ` not found in agent session map`);
         }
-        agentSession.sessions.push(sessionInfoToSessionData(msg));
+        // Check if session already exists
+        const existingSessionIndex = agentSession.sessions.findIndex((session) => session.session_uuid === msg.session_id);
+        if (existingSessionIndex !== -1) {
+            // Update existing session
+            agentSession.sessions[existingSessionIndex] =
+                sessionInfoToSessionDescriptor(msg);
+            logger.info(`[ChatClient] Updated existing session ${msg.session_id} in ` +
+                `agent session map`);
+        }
+        else {
+            // Add new session
+            agentSession.sessions.push(sessionInfoToSessionDescriptor(msg));
+            logger.info(`[ChatClient] Added new session ${msg.session_id} to agent session map`);
+        }
         agentSession.updated_at = new Date(msg.updated_at).getTime();
     }
+    // This is the immediate callback of the ResponseAwaiter for session
+    // joining.  It must create and register the client.
+    onJoinCreateResponse(msg) {
+        // Errors should not get through here.
+        (0, assert_1.strict)(msg.type === "session_info");
+        const sessionId = msg.session_id;
+        const client = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants), msg.agent_paused);
+        this.activeSessions.set(sessionId, client);
+        this.currentSessionId = sessionId;
+        if (msg.team_uuid) {
+            this.currentTeamId = msg.team_uuid;
+        }
+        this.upsertSessionToAgentSessionMap(msg);
+        return {
+            client,
+            sessionInfo: msg,
+        };
+    }
 }
 exports.ChatClient = ChatClient;
-function sessionInfoToSessionData(msg) {
+function sessionInfoToSessionDescriptor(msg) {
     return {
         session_uuid: msg.session_id,
         title: msg.title,
         team_uuid: msg.team_uuid,
         agent_profile_uuid: msg.saved_agent_profile.uuid,
-        workspace: msg.workspace,
         updated_at: msg.updated_at,
         user_uuid: msg.owner_uuid,
+        agent_paused: msg.agent_paused,
     };
 }
-/**
- * Update the agent session map
- * @param agentSessionMap - the agent session map
- * @param sessionInfo - the session info
- * @returns true if the session is updated, false otherwise
- */
-function doUpdateAgentSessionMap(agentSessionMap, sessionInfo) {
-    const sessionId = sessionInfo.session_id;
-    const agentUuid = sessionInfo.saved_agent_profile.uuid;
-    const agent = agentSessionMap.get(agentUuid);
-    if (!agent) {
-        return false;
-    }
-    let updated = false;
-    agent.sessions.map((session) => {
-        if (session.session_uuid === sessionId) {
-            updated = true;
-            return sessionInfoToSessionData(sessionInfo);
-        }
-        else {
-            return session;
-        }
-    });
-    return updated;
-}

package/dist/agent/src/chat/client/constants.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_CREATE_TIMEOUT = exports.SESSION_JOIN_TIMEOUT = void 0;
+exports.SESSION_JOIN_TIMEOUT = void 0;
 exports.SESSION_JOIN_TIMEOUT = 6000; // 6 seconds
-exports.SESSION_CREATE_TIMEOUT = 6000; // 6 seconds