@xalia/agent 0.6.0 → 0.6.2

package/src/agent/openAILLMStreaming.ts

@@ -1,8 +1,16 @@
-import { getLogger } from "@xalia/xmcp/sdk";
-import { ILLM } from "./llm";
 import { OpenAI } from "openai";
 import { strict as assert } from "assert";
-import { DEFAULT_LLM_MODEL, XALIA_APP_HEADER } from "./agentUtils";
+
+import { getLogger } from "@xalia/xmcp/sdk";
+
+import {
+  ILLM,
+  ChatCompletionChunkChoiceDeltaWithReasoning,
+  ChatCompletionMessageWithReasoning,
+  Reasoning,
+  choiceDeltaExtractReasoning,
+  XALIA_APP_HEADER,
+} from "./llm";
 
 const logger = getLogger();
 
@@ -186,9 +194,20 @@ function initializeCompletionMessage(
   };
 }
 
+function updateReasoning(
+  message: ChatCompletionMessageWithReasoning,
+  reasoning: string
+) {
+  if (!message.reasoning) {
+    message.reasoning = reasoning;
+  } else {
+    message.reasoning += reasoning;
+  }
+}
+
 function updateCompletionMessage(
-  message: OpenAI.Chat.Completions.ChatCompletionMessage,
-  delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta
+  message: ChatCompletionMessageWithReasoning,
+  delta: ChatCompletionChunkChoiceDeltaWithReasoning
 ) {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   assert(message.role === "assistant");
@@ -200,12 +219,20 @@ function updateCompletionMessage(
       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
+  //     }[]
   //   }
   //
   // ->
@@ -218,6 +245,8 @@ function updateCompletionMessage(
   //     audio?: ChatCompletionAudio | null;
   //     function_call?: ChatCompletionMessage.FunctionCall | null;
   //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+  //
+  //     reasoning?: string;
   //   }
 
   if (delta.content) {
@@ -242,6 +271,11 @@ function updateCompletionMessage(
       message.tool_calls = updateToolCalls(message.tool_calls, t);
     }
   }
+
+  const reasoning = choiceDeltaExtractReasoning(delta);
+  if (reasoning) {
+    updateReasoning(message, reasoning);
+  }
 }
 
 function initializeCompletionChoice(
@@ -451,18 +485,14 @@ export class OpenAILLMStreaming implements ILLM {
   private readonly openai: OpenAI;
   private model: string;
 
-  constructor(
-    apiKey: string,
-    apiUrl: string | undefined,
-    model: string | undefined
-  ) {
+  constructor(apiKey: string, apiUrl: string | undefined, model: string) {
     this.openai = new OpenAI({
       apiKey,
       baseURL: apiUrl,
       dangerouslyAllowBrowser: true,
       defaultHeaders: XALIA_APP_HEADER,
     });
-    this.model = model || DEFAULT_LLM_MODEL;
+    this.model = model;
   }
 
   public setModel(model: string) {
@@ -480,8 +510,13 @@ export class OpenAILLMStreaming implements ILLM {
   public async getConversationResponse(
     messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
     tools?: OpenAI.Chat.Completions.ChatCompletionTool[],
-    onMessage?: (msg: string, end: boolean) => Promise<void>
+    onMessage?: (msg: string, end: boolean) => Promise<void>,
+    onReasoning?: (reasoning: string) => Promise<void>
   ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+    const reasoning: Reasoning = {
+      effort: "medium",
+      enabled: true,
+    };
     const chunks = await this.openai.chat.completions.create({
       model: this.model,
       messages,
@@ -490,7 +525,8 @@ export class OpenAILLMStreaming implements ILLM {
       stream_options: {
         include_usage: true,
       },
-    });
+      extra_body: { reasoning },
+    } as OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming);
 
     // Check the type casting above
     if (!(chunks as unknown as { iterator: unknown }).iterator) {
@@ -498,6 +534,7 @@ export class OpenAILLMStreaming implements ILLM {
     }
 
     let aggregatedMessage: OpenAI.Chat.Completions.ChatCompletion | undefined;
+
     for await (const chunk of chunks) {
       logger.debug(`[stream] chunk: ${JSON.stringify(chunk)}`);
 
@@ -526,6 +563,15 @@ export class OpenAILLMStreaming implements ILLM {
           await onMessage(delta.content, false);
         }
       }
+
+      if (onReasoning) {
+        const delta = chunk.choices[0]
+          ?.delta as ChatCompletionChunkChoiceDeltaWithReasoning;
+        const reasoning = choiceDeltaExtractReasoning(delta);
+        if (reasoning) {
+          await onReasoning(reasoning);
+        }
+      }
     }
 
     if (onMessage) {

package/src/chat/client/chatClient.ts

@@ -6,10 +6,10 @@ import { Connection } from "./connection";
 import { SessionClient } from "./sessionClient";
 import { IChatClientEventHandler } from "./interfaces";
 import {
-  SessionData,
   TeamInfo,
   TeamParticipant,
   AgentSessionData,
+  SessionDescriptor,
 } from "../data/dataModels";
 import { createSessionParticipantMap } from "../data/database";
 import {
@@ -21,6 +21,7 @@ import {
   ServerControlMessage,
   ServerControlSessionDeleted,
   ServerControlTeamCreated,
+  ServerControlTeamMembersUpdated,
   ServerToClient,
   ClientToServer,
   ServerControlAgentProfileCreated,
@@ -59,6 +60,8 @@ export class ChatClient implements ITeamManager {
     private userAgentSessionMap: Map<string, AgentSessionData> = new Map(),
     // team_uuid -> team info
     private teams: Map<string, ClientTeamInfo> = new Map(),
+    // Whether this client is in guest mode
+    private isGuestMode: boolean = false,
     private closed: boolean = false,
     private currentSessionId: string | undefined = undefined,
     // note: currentTeamId will not be reset when swtiching to a user session.
@@ -81,6 +84,9 @@ export class ChatClient implements ITeamManager {
     token: string,
     eventHandler: IChatClientEventHandler
   ): Promise<ChatClient> {
+    // Determine if this is a guest token (format: guest_<hash>_<session-id>)
+    const isGuestMode = token.startsWith('guest_');
+    
     const connection = new Connection<ClientToServer, ServerToClient>({
       url,
       token,
@@ -92,7 +98,7 @@ export class ChatClient implements ITeamManager {
       // Register session_info handler for initialization
       connection.on("control_session_list", (msg) => {
         // get user sessions, user agents, and team sessions
-        const userSessions = new Map<string, SessionData>();
+        const userSessions = new Map<string, SessionDescriptor>();
         msg.user_sessions.forEach((session) => {
           userSessions.set(session.session_uuid, session);
         });
@@ -127,7 +133,8 @@ export class ChatClient implements ITeamManager {
             connection,
             eventHandler,
             userAgentSessionMap,
-            teams
+            teams,
+            isGuestMode
           );
           resolveClient(client);
         } else {
@@ -476,6 +483,27 @@ export class ChatClient implements ITeamManager {
     );
   }
 
+  /**
+   * 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: string): void {
+    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
@@ -644,6 +672,9 @@ export class ChatClient implements ITeamManager {
       case "control_team_created":
         this.handleTeamCreatedMessage(msg);
         break;
+      case "control_team_members_updated":
+        this.handleTeamMembersUpdated(msg);
+        break;
       default: {
         const _exhaustive: never = msg;
         throw new Error(`unexpected control msg: ${JSON.stringify(msg)}`);
@@ -676,8 +707,36 @@ export class ChatClient implements ITeamManager {
     void this.eventHandler.onMessage(msg, this);
   }
 
-  private handleAgentProfileDeleted(_msg: ServerControlAgentProfileDeleted) {
-    throw new Error("handleAgentProfileDeleted not implemented");
+  private handleAgentProfileDeleted(msg: ServerControlAgentProfileDeleted) {
+    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);
   }
 
   private handleSessionMessage(msg: ServerSessionScopedMessage): void {
@@ -725,6 +784,28 @@ export class ChatClient implements ITeamManager {
     return;
   }
 
+  private handleTeamMembersUpdated(msg: ServerControlTeamMembersUpdated): void {
+    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
@@ -751,7 +832,8 @@ export class ChatClient implements ITeamManager {
           msg.saved_agent_profile,
           this.connection,
           msg.mcp_server_briefs,
-          createSessionParticipantMap(msg.participants)
+          createSessionParticipantMap(msg.participants),
+          msg.agent_paused
         );
 
         // we need to pass the session id if this is a new session
@@ -797,12 +879,23 @@ export class ChatClient implements ITeamManager {
    */
   private updateAgentSessionMap(sessionInfo: ServerSessionInfo): void {
     const sessionId = sessionInfo.session_id;
+    
+    // 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 update for ` +
+          `guest session ${sessionId}`
+      );
+      return;
+    }
+
     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(
@@ -822,9 +915,9 @@ export class ChatClient implements ITeamManager {
   }
 
   /**
-   * 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.
+   * Update the SessionDescriptor info for an existing session, given a full
+   * ServerSessionInfo. This also passes the session info to the session
+   * client. An error is thrown if the session client is not found.
    */
   private updateSessionInfo(msg: ServerSessionInfo): void {
     const sessionId = msg.session_id;
@@ -838,6 +931,16 @@ export class ChatClient implements ITeamManager {
   }
 
   private addSessionToAgentSessionMap(msg: ServerSessionInfo): void {
+    // 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;
+    }
+
     // get the correct agent session map
     const agentSessionMap = msg.team_uuid
       ? this.teams.get(msg.team_uuid)?.agentSessionMap
@@ -854,20 +957,22 @@ export class ChatClient implements ITeamManager {
           ` not found in agent session map`
       );
     }
-    agentSession.sessions.push(sessionInfoToSessionData(msg));
+    agentSession.sessions.push(sessionInfoToSessionDescriptor(msg));
     agentSession.updated_at = new Date(msg.updated_at).getTime();
   }
 }
 
-function sessionInfoToSessionData(msg: ServerSessionInfo): SessionData {
+function sessionInfoToSessionDescriptor(
+  msg: ServerSessionInfo
+): SessionDescriptor {
   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,
   };
 }
 
@@ -891,7 +996,7 @@ function doUpdateAgentSessionMap(
   agent.sessions.map((session) => {
     if (session.session_uuid === sessionId) {
       updated = true;
-      return sessionInfoToSessionData(sessionInfo);
+      return sessionInfoToSessionDescriptor(sessionInfo);
     } else {
       return session;
     }

package/src/chat/client/sessionClient.ts

@@ -11,7 +11,8 @@ import {
 
 import { ISkillManager } from "../../agent/sudoMcpServerManager";
 import { McpServerInfo, McpServerInfoRW } from "../../agent/mcpServerManager";
-import { ChatCompletionMessageParam, IConversation } from "../../agent/agent";
+import { IConversation } from "../../agent/agent";
+import { ChatCompletionMessageParam } from "../../agent/llm";
 
 import {
   ClientSessionMessage,
@@ -20,11 +21,15 @@ import {
   ServerSessionInfo,
   ClientSetWorkspace,
   ClientToServer,
+  isServerSessionFileMessage,
 } from "../protocol/messages";
 import { SessionParticipantMap } from "../data/dataModels";
 import { createSessionParticipantMap } from "../data/database";
 import { ISessionMessageSender } from "./interfaces";
 import { IMessageSender } from "./connection";
+import { SessionFiles } from "./sessionFiles";
+import { SessionFileDescriptor } from "../data/dbSessionFileModels";
+import { ResponseHandler } from "./responseHandler";
 
 const logger = getLogger();
 
@@ -201,28 +206,51 @@ class RemoteSudoMcpServerManager implements ISkillManager {
 }
 
 export class SessionClient implements ISessionMessageSender, IConversation {
-  private smsm: RemoteSudoMcpServerManager;
+  private readonly sessionUUID: string;
+  private readonly savedAgentProfile: SavedAgentProfile;
+  private readonly sender: IMessageSender<ClientToServer>;
+  private readonly smsm: RemoteSudoMcpServerManager;
+  private readonly sessionFiles: SessionFiles;
+  private readonly responseHandler: ResponseHandler<
+    ClientSessionMessage,
+    ServerSessionScopedMessage
+  >;
+  private participants: SessionParticipantMap;
   private systemPrompt: string;
   private model: string;
+  private agentPaused: boolean;
 
   public constructor(
-    private sessionUUID: string,
-    private savedAgentProfile: SavedAgentProfile,
-    private sender: IMessageSender<ClientToServer>,
+    sessionUUID: string,
+    savedAgentProfile: SavedAgentProfile,
+    sender: IMessageSender<ClientToServer>,
     serverBriefs: McpServerBrief[],
-    private participants: SessionParticipantMap
+    participants: SessionParticipantMap,
+    agentPaused: boolean
   ) {
+    const fileList: SessionFileDescriptor[] = []; // Pass in?
+    this.sessionUUID = sessionUUID;
+    this.savedAgentProfile = savedAgentProfile;
     this.sender = sender;
     this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
+    this.sessionFiles = new SessionFiles(sessionUUID, fileList, sender);
+    this.responseHandler = new ResponseHandler("session_error");
+    this.participants = participants;
     this.systemPrompt = "";
     this.model = "";
-    this.participants = participants;
+    this.agentPaused = agentPaused;
   }
 
   public getSessionUUID(): string {
     return this.sessionUUID;
   }
 
+  /// This object can be queried to upload or download files, or get the
+  /// latest list. See `SessionFiles` for full usage.
+  public getSessionFiles(): SessionFiles {
+    return this.sessionFiles;
+  }
+
   public getSudoMcpServerManager(): ISkillManager {
     return this.smsm;
   }
@@ -262,6 +290,17 @@ export class SessionClient implements ISessionMessageSender, IConversation {
     this.sendSessionMessage({ type: "set_model", model });
   }
 
+  getAgentPaused(): boolean {
+    return this.agentPaused;
+  }
+
+  setAgentPaused(paused: boolean) {
+    this.sendSessionMessage({
+      type: "set_agent_paused",
+      paused,
+    });
+  }
+
   userMessage(msg?: string, imageB64?: string): void {
     assert(msg || imageB64, "Either message or image must be provided");
 
@@ -343,8 +382,7 @@ export class SessionClient implements ISessionMessageSender, IConversation {
   }
 
   public updateSessionInfo(sessionInfo: ServerSessionInfo): void {
-    // TODO: Implement this
-    // throw new Error("[SessionClient.updateSessionInfo] not implemented");
+    // TODO: Determine the correct approach. Cache the workspace?
     const infoStr = JSON.stringify(sessionInfo.workspace);
     logger.debug(`[SessionClient] ignoring session info: ${infoStr}`);
   }
@@ -382,7 +420,28 @@ export class SessionClient implements ISessionMessageSender, IConversation {
     });
   }
 
+  public async shareSession(): Promise<string> {
+    const msg: ClientToServer = {
+      type: "share_session",
+      client_message_id: uuidv4(),
+      session_id: this.sessionUUID,
+    };
+
+    this.sender.send(msg);
+    const response = await this.responseHandler.waitForResponse(msg);
+    if (response.type === "session_shared") {
+      return response.access_token;
+    }
+
+    throw new Error(`unexpected response to "share"session": ${response.type}`);
+  }
+
   handleMessage(message: ServerSessionScopedMessage): void {
+    if (isServerSessionFileMessage(message)) {
+      this.sessionFiles.onMessage(message);
+      return;
+    }
+
     switch (message.type) {
       //
       // State updates
@@ -427,6 +486,13 @@ export class SessionClient implements ISessionMessageSender, IConversation {
       case "user_removed":
         this.participants.delete(message.user_uuid);
         break;
+      case "session_shared":
+        this.responseHandler.onMessage(message);
+        break;
+
+      case "agent_paused":
+        this.agentPaused = message.paused;
+        break;
 
       //
       // Ignore other messages - the owner (the UI layer) can handle them at