@xalia/agent 0.6.0 → 0.6.2

package/src/chat/server/openSession.ts

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import { strict as assert } from "assert";
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
 
@@ -11,20 +12,16 @@ import {
   SavedAgentProfile,
 } from "@xalia/xmcp/sdk";
 
+import { Agent, createUserMessage } from "../../agent/agent";
 import {
-  Agent,
   ChatCompletionAssistantMessageParam,
   ChatCompletionMessageToolCall,
   ChatCompletionToolMessageParam,
-  createUserMessage,
-} from "../../agent/agent";
+} from "../../agent/llm";
 import { SkillManager } from "../../agent/sudoMcpServerManager";
 import { McpServerInfo } from "../../agent/mcpServerManager";
 import { IAgentEventHandler } from "../../agent/iAgentEventHandler";
-import {
-  createAgentWithoutSkills,
-  DEFAULT_LLM_MODEL,
-} from "../../agent/agentUtils";
+import { createAgentWithoutSkills } from "../../agent/agentUtils";
 import { IPlatform } from "../../agent/iplatform";
 
 import type {
@@ -45,7 +42,12 @@ import type {
   ServerSessionInfo,
   ServerSessionUpdate,
   ClientSetWorkspace,
+  ClientToServer,
+  ServerSessionFileContent,
   ClientSetMcpServerConfig,
+  ClientShareSession,
+  ClientSessionMessageBase,
+  ServerAgentPaused,
 } from "../protocol/messages";
 import { AsyncQueue } from "../utils/asyncQueue";
 import { MultiAsyncQueue } from "../utils/multiAsyncQueue";
@@ -57,6 +59,7 @@ import {
   TeamParticipant,
   SessionCreateData,
   UserMessageData,
+  SessionDescriptor,
 } from "../data/dataModels";
 import {
   Database,
@@ -71,17 +74,32 @@ import {
   llmUserMessageToUserMessageData,
   MESSAGE_INDEX_START_VALUE,
 } from "./conversation";
-import { ChatSessionFileManager } from "./sessionFileManager";
+import {
+  ChatSessionFileManager,
+  ISessionFileManager,
+  ISessionFileManagerEventHandler,
+} from "./sessionFileManager";
 import { IUserConnectionManager } from "./connectionManager";
 import { getErrorString } from "./errorUtils";
 import { NODE_PLATFORM } from "../../tool/nodePlatform";
 import { DbMcpServerConfigs } from "../data/dbMcpServerConfigs";
+import { SessionFileEntry } from "../data/dbSessionFileModels";
+import { ApiKeyManager } from "../data/apiKeyManager";
+import { DbSessionMessages } from "../data/dbSessionMessages";
+
+/**
+ * The model to use when the AgentProfile does not specify one.
+ */
+const DEFAULT_CHAT_LLM_MODEL =
+  process.env["DEFAULT_LLM_MODEL"] || "anthropic/claude-sonnet-4.5";
 
 /**
  * Num messages to load at conversation startup.
  */
 export const DEFAULT_NUM_MESSGAES = 500;
 
+export const GUEST_TOKEN_PREFIX = "guest";
+
 const logger = getLogger();
 
 type QueuedClientMessage<
@@ -119,7 +137,9 @@ class DBCheckpointWriter implements ICheckpointWriter {
  * be seen until user messages had been fully processed, which could block
  * tool approvals and other interactions).
  */
-export class OpenSession implements IAgentEventHandler, IPlatform {
+export class OpenSession
+  implements IAgentEventHandler, ISessionFileManagerEventHandler, IPlatform
+{
   private readonly db: Database;
   private /* readonly */ agent: Agent;
   private readonly sessionUUID: string;
@@ -135,9 +155,12 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
   private readonly contextManager: ChatContextManager;
   private readonly approvalManager: ApprovalManager;
   private readonly savedAgentProfile: SavedAgentProfile;
+  private readonly sessionFileManager: ISessionFileManager;
   private isPersisted: boolean;
+  private accessToken: string | undefined;
   private sessionTitle: string;
   private sessionUpdatedAt: string;
+  private agentPaused: boolean;
 
   private constructor(
     db: Database,
@@ -150,7 +173,8 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     skillManager: SkillManager,
     contextManager: ChatContextManager,
     connectionManager: IUserConnectionManager<ServerToClient>,
-    approvalManager: ApprovalManager = new ApprovalManager()
+    approvalManager: ApprovalManager,
+    fileManager: ISessionFileManager
   ) {
     this.db = db;
     this.agent = agent;
@@ -158,6 +182,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     this.teamUUID = sessionData.team_uuid;
     this.userUUID = sessionData.user_uuid;
     this.agentProfileUUID = sessionData.agent_profile_uuid;
+    this.accessToken = sessionData.access_token;
     this.sessionParticipants = sessionParticipants;
     this.agentProfilePreferences = agentProfilePreferences;
     this.skillManager = skillManager;
@@ -172,13 +197,18 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     this.contextManager = contextManager;
     this.approvalManager = approvalManager;
     this.savedAgentProfile = savedAgentProfile;
+    this.sessionFileManager = fileManager;
     this.isPersisted = isPersisted;
     this.sessionTitle = sessionData.title;
     this.sessionUpdatedAt = sessionData.updated_at;
+    this.agentPaused = sessionData.agent_paused;
+
+    fileManager.addEventHandler(this);
   }
 
   private static async init(
     db: Database,
+    isPersisted: boolean,
     sessionData: SessionData,
     savedAgentProfile: SavedAgentProfile,
     sessionMessages: SessionMessage[],
@@ -191,7 +221,8 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     connectionManager: IUserConnectionManager<ServerToClient>
   ): Promise<OpenSession> {
     const sessionId = sessionData.session_uuid;
-    const fileManager = new ChatSessionFileManager(sessionId, db);
+
+    const fileManager = await ChatSessionFileManager.init(db, sessionId);
     const contextManager = new ChatContextManager(
       savedAgentProfile.profile.system_prompt,
       sessionMessages,
@@ -199,7 +230,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       ownerData.uuid,
       sessionCheckpoint,
       llmUrl,
-      savedAgentProfile.profile.model || DEFAULT_LLM_MODEL,
+      savedAgentProfile.profile.model || DEFAULT_CHAT_LLM_MODEL,
       ownerApiKey,
       new DBCheckpointWriter(db, sessionId),
       fileManager
@@ -214,12 +245,14 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       {} as Agent, // Placeholder - will be replaced after agent creation
       sessionData,
       savedAgentProfile,
-      false /* isPersisted */,
+      isPersisted,
       sessionParticipants,
       savedAgentProfile.preferences,
       {} as SkillManager, // Placeholder - will be replaced after agent creation
       contextManager,
-      connectionManager
+      connectionManager,
+      new ApprovalManager(),
+      fileManager
     );
 
     // Initialize an empty agent (to ensure there are no callbacks before
@@ -229,6 +262,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     const [agent, skillManager] = await createAgentWithoutSkills(
       llmUrl,
       savedAgentProfile.profile,
+      DEFAULT_CHAT_LLM_MODEL,
       openSession,
       openSession,
       contextManager,
@@ -237,7 +271,14 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       undefined,
       true
     );
-    await addDefaultChatTools(agent, ownerData.timezone, openSession);
+    await addDefaultChatTools(
+      agent,
+      ownerData.timezone,
+      openSession,
+      fileManager,
+      llmUrl,
+      ownerApiKey
+    );
 
     // Update OpenSession with real agent and skillManager
     openSession.agent = agent;
@@ -279,6 +320,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
 
     return OpenSession.init(
       db,
+      false /* isPersisted */,
       sessionData,
       savedAgentProfile,
       sessionMessages,
@@ -311,6 +353,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     } = await loadSessionData(db, sessionId);
     return OpenSession.init(
       db,
+      true /* isPersisted */,
       sessionData,
       savedAgentProfile,
       sessionMessages,
@@ -328,6 +371,23 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     logger.info(`[OpenSession.onEmpty] session ${this.sessionUUID}`);
   }
 
+  getDescriptor(): SessionDescriptor {
+    assert(
+      typeof this.accessToken === "string" ||
+        typeof this.accessToken === "undefined"
+    );
+    return {
+      session_uuid: this.sessionUUID,
+      title: this.sessionTitle,
+      agent_profile_uuid: this.agentProfileUUID,
+      user_uuid: this.userUUID,
+      team_uuid: this.teamUUID,
+      access_token: this.accessToken,
+      updated_at: this.sessionUpdatedAt,
+      agent_paused: this.agentPaused,
+    };
+  }
+
   getParticipants(): SessionParticipantMap {
     return this.sessionParticipants;
   }
@@ -340,6 +400,17 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     const sessionInfo = this.serverSessionInfo(clientMessageId);
     this.connectionManager.sendToConnection(connectionId, sessionInfo);
 
+    // send session file info
+    const fileDescriptors = this.sessionFileManager.listFiles();
+    fileDescriptors.forEach((descriptor) => {
+      this.connectionManager.sendToConnection(connectionId, {
+        type: "session_file_changed",
+        session_id: this.sessionUUID,
+        descriptor,
+        new_file: false,
+      });
+    });
+
     // send conversation history
     const conversationMessages = this.contextManager.getConversationMessages();
     conversationMessages.forEach((message) => {
@@ -522,6 +593,12 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     this.contextManager.processAgentResponse(result);
   }
 
+  // IAgentEventHandler.onImage
+  onImage(image: OpenAI.Chat.Completions.ChatCompletionContentPartImage): void {
+    logger.debug(`[OpenSession.onImage] : ${image.image_url.url}`);
+    throw new Error("[OpenSession.onImage] unimplemented");
+  }
+
   // IAgentEventHandler.onToolCallResult
   onToolCallResult(result: ChatCompletionToolMessageParam): void {
     logger.debug(`[onToolCallResult] : ${JSON.stringify(result)}`);
@@ -614,6 +691,44 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     this.broadcast(agentMsgChunk);
   }
 
+  // IAgentEventHandler.onReasoning
+  onReasoning(reasoning: string): Promise<void> {
+    return new Promise<void>((r) => {
+      logger.debug(`[OpenSession.onReasoning]${reasoning}`);
+      if (reasoning.length > 0) {
+        this.broadcast({
+          type: "agent_reasoning_chunk",
+          reasoning,
+          session_id: this.sessionUUID,
+        });
+      }
+      r();
+    });
+  }
+
+  // ISessionFileManagerEventHandler.onFileDeleted
+  onFileDeleted(name: string): void {
+    this.broadcast({
+      type: "session_file_deleted",
+      session_id: this.sessionUUID,
+      name,
+    });
+  }
+
+  // ISessionFileManagerEventHandler.onFileChanged
+  onFileChanged(entry: SessionFileEntry, new_file: boolean): void {
+    this.broadcast({
+      type: "session_file_changed",
+      session_id: this.sessionUUID,
+      descriptor: {
+        name: entry.name,
+        mime_type: entry.mime_type,
+        summary: entry.summary,
+      },
+      new_file,
+    });
+  }
+
   /**
    * Handle incoming session-related message from client.
    * These messages include tool calls, MCP changes, etc.
@@ -693,34 +808,38 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
         undefined;
       switch (msg.type) {
         case "msg":
-          broadcastMsg = this.onUserMessage(msg, queuedMessage.from);
+          broadcastMsg = this.handleUserMessage(msg, queuedMessage.from);
           break;
         case "add_mcp_server":
-          broadcastMsg = await this.onAddMcpServer(
+          broadcastMsg = await this.handleAddMcpServer(
             msg.server_name,
             msg.enable_all
           );
           break;
         case "remove_mcp_server":
-          broadcastMsg = await this.onRemoveMcpServer(msg.server_name);
+          broadcastMsg = await this.handleRemoveMcpServer(msg.server_name);
           break;
         case "enable_mcp_server_tool":
-          broadcastMsg = await this.onEnableMcpServerTool(
+          broadcastMsg = await this.handleEnableMcpServerTool(
             msg.server_name,
             msg.tool
           );
           break;
         case "disable_mcp_server_tool":
-          broadcastMsg = await this.onDisableMcpServerTool(
+          broadcastMsg = await this.handleDisableMcpServerTool(
             msg.server_name,
             msg.tool
           );
           break;
         case "enable_all_mcp_server_tools":
-          broadcastMsg = await this.onEnableAllMcpServerTools(msg.server_name);
+          broadcastMsg = await this.handleEnableAllMcpServerTools(
+            msg.server_name
+          );
           break;
         case "disable_all_mcp_server_tools":
-          broadcastMsg = await this.onDisableAllMcpServerTools(msg.server_name);
+          broadcastMsg = await this.handleDisableAllMcpServerTools(
+            msg.server_name
+          );
           break;
         case "tool_call_approval_result":
           if (
@@ -738,6 +857,15 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
             };
           }
           break;
+        case "session_file_get_content":
+          void this.handleSessionFileGetContent(msg, queuedMessage.from);
+          break;
+        case "session_file_delete":
+          await this.handleSessionFileDelete(msg);
+          break;
+        case "session_file_put_content":
+          await this.handleSessionFilePutContent(msg);
+          break;
         case "set_auto_approval":
           broadcastMsg = await this.onSetAutoApproval(
             msg.server_name,
@@ -746,17 +874,23 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
           );
           break;
         case "set_system_prompt":
-          broadcastMsg = await this.onSetSystemPrompt(msg.system_prompt);
+          broadcastMsg = await this.handleSetSystemPrompt(msg.system_prompt);
           break;
         case "set_model":
-          broadcastMsg = await this.onSetModel(msg.model);
+          broadcastMsg = await this.handleSetModel(msg.model);
+          break;
+        case "set_agent_paused":
+          broadcastMsg = await this.handleSetAgentPaused(msg.paused);
           break;
         case "set_workspace":
-          await this.onSetWorkspace(msg, queuedMessage.from);
+          await this.handleSetWorkspace(msg, queuedMessage.from);
           break;
         case "set_mcp_server_config":
           await this.handleSetMcpServerConfig(msg, queuedMessage.from);
           break;
+        case "share_session":
+          await this.handleShareSession(msg, queuedMessage.from);
+          break;
         default: {
           const exhaustive: never = msg; // Error => non-exhaustive switch-case.
           return exhaustive;
@@ -779,7 +913,28 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     }
   }
 
-  private async onSetWorkspace(
+  private async handleShareSession(
+    msg: ClientShareSession & ClientSessionMessageBase,
+    from: string
+  ) {
+    if (!this.accessToken) {
+      const accessToken = ApiKeyManager.createApiKeyWithPayload(
+        GUEST_TOKEN_PREFIX,
+        this.sessionUUID
+      );
+      await this.db.sessionUpdateAccessToken(this.sessionUUID, accessToken);
+      this.accessToken = accessToken;
+    }
+
+    this.sendTo(from, {
+      type: "session_shared",
+      access_token: this.accessToken,
+      client_message_id: msg.client_message_id,
+      session_id: this.sessionUUID,
+    });
+  }
+
+  private async handleSetWorkspace(
     msg: ClientSetWorkspace,
     sender: string
   ): Promise<void> {
@@ -799,18 +954,32 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     assert(this.isPersisted);
   }
 
-  private async processUserMessages(msgs: ServerUserMessage[]): Promise<void> {
-    if (msgs.length === 0) {
-      logger.debug("ignoring empty messages");
-      return;
-    }
+  /**
+   * `processUserMessage` logic when agent is paused.  Trigger the context,
+   * add the user messages and then extract the new DB messages.
+   */
+  private processUserMessagePaused(
+    msgs: ServerUserMessage[]
+  ): SessionMessage[] {
+    const { llmUserMessages } = this.contextManager.startAgentResponse(msgs);
+
+    // Just send the user LLM messages direct to the ContextManager, so they
+    // are available to the LLM once it is restarted.
 
-    // Begin an agent response using the accumulated user messages.
+    this.contextManager.addMessages(llmUserMessages);
+    return this.contextManager.endAgentResponse();
+  }
 
+  /**
+   * `processUserMessage` logic when agent is active.  Start the Agent loop,
+   * adding all agent messages to the context. Extract the new DB messages.
+   */
+  private async processUserMessagesActive(
+    msgs: ServerUserMessage[]
+  ): Promise<SessionMessage[]> {
     const { llmUserMessages, agentFirstChunk } =
       this.contextManager.startAgentResponse(msgs);
     this.broadcast(agentFirstChunk);
-
     try {
       await this.agent.userMessagesRaw(llmUserMessages);
     } catch (e) {
@@ -824,10 +993,16 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       await this.onAgentMessage(errMsg, true);
       const err = this.contextManager.revertAgentResponse(errMsg);
       this.broadcast(err);
-      return;
+
+      // return await this.processuserMessagesActive(msgs);
     }
+    return this.contextManager.endAgentResponse();
+  }
 
-    const newSessionMessages = this.contextManager.endAgentResponse();
+  private async processUserMessages(msgs: ServerUserMessage[]): Promise<void> {
+    const newSessionMessages = this.agentPaused
+      ? this.processUserMessagePaused(msgs)
+      : await this.processUserMessagesActive(msgs);
 
     logger.debug(
       "[processUserMessages] newSessionMessages: " +
@@ -836,7 +1011,8 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
 
     try {
       // Append to in-memory conversation and write to the DB
-      await this.db.sessionMessagesAppend(this.sessionUUID, newSessionMessages);
+      const dbsm = this.db.createTypedClient(DbSessionMessages);
+      await dbsm.append(this.sessionUUID, newSessionMessages);
     } catch (e) {
       if (!this.handleError(e)) {
         throw e;
@@ -844,7 +1020,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     }
   }
 
-  private onUserMessage(
+  private handleUserMessage(
     msg: ClientUserMessage,
     from: string
   ): ServerUserMessage | undefined {
@@ -858,7 +1034,9 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     // Assign the user message_idx and attempt to enqueue.
 
     const userMessage = this.contextManager.processUserMessage(msg, from);
-
+    if (!userMessage) {
+      return;
+    }
     // Special case for the first message of the session
 
     if (userMessage.message_idx === MESSAGE_INDEX_START_VALUE) {
@@ -893,14 +1071,20 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       title: this.sessionTitle,
       team_uuid: this.teamUUID,
       agent_profile_uuid: this.agentProfileUUID,
-      workspace: this.workspaceUserMessageData(),
       user_uuid: this.userUUID,
+      agent_paused: false,
     };
     logger.info(
       `[OpenSession.onFirstMessage] writing session ${this.sessionUUID}`
     );
 
     await this.db.sessionCreate(sessionCreateData);
+
+    const workspace = this.workspaceUserMessageData();
+    if (workspace) {
+      await this.db.sessionUpdateWorkspace(this.sessionUUID, workspace);
+    }
+
     this.isPersisted = true;
   }
 
@@ -929,7 +1113,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     this.broadcast(msg);
   }
 
-  private async onAddMcpServer(
+  private async handleAddMcpServer(
     serverName: string,
     enableAll: boolean
   ): Promise<ServerMcpServerAdded> {
@@ -967,7 +1151,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     };
   }
 
-  private async onRemoveMcpServer(
+  private async handleRemoveMcpServer(
     server_name: string
   ): Promise<ServerMcpServerRemoved> {
     logger.info(`[onRemoveMcpServer]: Removing server ${server_name}`);
@@ -986,7 +1170,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     };
   }
 
-  private async onEnableMcpServerTool(
+  private async handleEnableMcpServerTool(
     server_name: string,
     tool: string
   ): Promise<ServerMcpServerToolEnabled> {
@@ -1003,7 +1187,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     };
   }
 
-  private async onDisableMcpServerTool(
+  private async handleDisableMcpServerTool(
     server_name: string,
     tool: string
   ): Promise<ServerMcpServerToolDisabled> {
@@ -1020,7 +1204,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     };
   }
 
-  private async onEnableAllMcpServerTools(
+  private async handleEnableAllMcpServerTools(
     server_name: string
   ): Promise<ServerMcpServerToolEnabled[]> {
     // We reimplement the logic to enable any disabled tools so we can
@@ -1046,7 +1230,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     return msgs;
   }
 
-  private async onDisableAllMcpServerTools(
+  private async handleDisableAllMcpServerTools(
     server_name: string
   ): Promise<ServerMcpServerToolDisabled[]> {
     // We reimplement the logic to disable all enabled tools so we can
@@ -1070,7 +1254,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     return msgs;
   }
 
-  private async onSetSystemPrompt(
+  private async handleSetSystemPrompt(
     system_prompt: string
   ): Promise<ServerSystemPromptUpdated> {
     this.agent.setSystemPrompt(system_prompt);
@@ -1082,12 +1266,20 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     };
   }
 
-  private async onSetModel(model: string): Promise<ServerModelUpdated> {
+  private async handleSetModel(model: string): Promise<ServerModelUpdated> {
     this.agent.setModel(model);
     await this.updateAgentProfile();
     return { type: "model_updated", model, session_id: this.sessionUUID };
   }
 
+  private async handleSetAgentPaused(
+    paused: boolean
+  ): Promise<ServerAgentPaused> {
+    this.agentPaused = paused;
+    await this.db.sessionSetAgentPaused(this.sessionUUID, paused);
+    return { type: "agent_paused", session_id: this.sessionUUID, paused };
+  }
+
   private async handleSetMcpServerConfig(
     msg: ClientSetMcpServerConfig,
     from: string
@@ -1120,6 +1312,50 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
     // TODO: Do we want to braodcast an "mcp_server_config_updated" message?
   }
 
+  private async handleSessionFileGetContent(
+    msg: Extract<ClientToServer, { type: "session_file_get_content" }>,
+    from: string
+  ): Promise<void> {
+    const data_url = await this.sessionFileManager.getFileContent(msg.name);
+    const contentMsg: ServerSessionFileContent = {
+      type: "session_file_content",
+      session_id: this.sessionUUID,
+      client_message_id: msg.client_message_id,
+      name: msg.name,
+      data_url,
+    };
+    this.sendTo(from, contentMsg);
+  }
+
+  private async handleSessionFileDelete(
+    msg: Extract<ClientToServer, { type: "session_file_delete" }>
+  ): Promise<void> {
+    await this.sessionFileManager.deleteFile(msg.name);
+    // Note, the SessionFileManager will call us back via
+    // `ISessionFileManagerEventHandler.onFileDeleted` if the deletion
+    // succeeds.  We broadcast in that callback.
+  }
+
+  private async handleSessionFilePutContent(
+    msg: Extract<ClientToServer, { type: "session_file_put_content" }>
+  ): Promise<void> {
+    // If the session hasn't been persisted, it must be written to the DB,
+    // (otherwise the sessionId in the SessionFiles entry will not be
+    // considered valid byt he DB).
+
+    if (!this.isPersisted) {
+      await this.createSessionInDB();
+    }
+    await this.sessionFileManager.putFileContent(
+      msg.name,
+      msg.summary,
+      msg.data_url
+    );
+    // Note, the SessionFileManager will call us back via
+    // `ISessionFileManagerEventHandler.onFileChanged` if the deletion
+    // succeeds.  We broadcast in that callback.
+  }
+
   private async onSetAutoApproval(
     serverName: string,
     tool: string,
@@ -1239,6 +1475,7 @@ export class OpenSession implements IAgentEventHandler, IPlatform {
       client_message_id: clientMessageId,
       session_id: this.sessionUUID,
       team_uuid: this.teamUUID,
+      agent_paused: this.agentPaused,
     };
   }
 
@@ -1302,10 +1539,11 @@ async function loadSessionData(
   ownerApiKey: string;
   sessionParticipants: SessionParticipantMap;
 }> {
+  const dbsm = db.createTypedClient(DbSessionMessages);
   const [sessionData, sessionMessages, sessionParticipants, sessionCheckpoint] =
     await Promise.all([
-      db.sessionGetById(sessionId),
-      db.sessionMessagesGetConversation(sessionId, DEFAULT_NUM_MESSGAES, 0),
+      db.sessionGetDescriptorById(sessionId),
+      dbsm.getConversation(sessionId, DEFAULT_NUM_MESSGAES, 0),
       db.sessionGetParticipants(sessionId),
       db.sessionCheckpointGet(sessionId),
     ]);