@xalia/agent 0.6.3 → 0.6.5

package/src/agent/openAI.ts

@@ -0,0 +1,123 @@
+import { OpenAI } from "openai";
+
+/**
+ *
+ * Extension to the OpenAI messages to support custom elements added by other
+ * providers.  These represent the data returned by from provider APIs, which
+ * may not match our internal structures.
+ *
+ */
+
+export type ChatCompletionContentPartImage =
+  OpenAI.Chat.Completions.ChatCompletionContentPartImage;
+
+export type ChatCompletionMessageToolCall =
+  OpenAI.Chat.Completions.ChatCompletionMessageToolCall;
+
+// Extend the ChatCompletionMessage type with an `images` value, compatible
+// with google/gemini-2.5-flash-image-preview.
+export interface ChatCompletionMessage
+  extends OpenAI.Chat.Completions.ChatCompletionMessage {
+  images?: ChatCompletionContentPartImage[];
+}
+
+// Extend ChatCompletionChoice with messages containing images
+export interface ChatCompletionChoice
+  extends OpenAI.Chat.Completions.ChatCompletion.Choice {
+  message: ChatCompletionMessage;
+}
+
+// Extends ChatCompletion with Choices containing images
+export interface ChatCompletion extends OpenAI.Chat.Completions.ChatCompletion {
+  choices: Array<ChatCompletionChoice>;
+}
+
+// TODO: Do we need these?  They are input types, generally for convenience.
+// Instead, we could just make sure our internal types are compatible with the
+// OpenAI definition.
+
+// Expose for conveinence for now
+
+export type ChatCompletionAssistantMessageParam =
+  OpenAI.ChatCompletionAssistantMessageParam;
+
+export type ChatCompletionContentPart = OpenAI.ChatCompletionContentPart;
+
+export type ChatCompletionUserMessageParam =
+  OpenAI.ChatCompletionUserMessageParam;
+
+// export type ToolMessageParam = OpenAI.ChatCompletionToolMessageParam;
+
+// openrouter reasoning types
+
+export type ReasoningEffort = {
+  effort?: OpenAI.ReasoningEffort;
+  max_tokens?: never;
+};
+
+export type ReasoningMaxTokens = { effort?: never; max_tokens?: number };
+
+export type ReasoningExclude = { exclude?: boolean; enabled?: never };
+
+export type ReasoningEnabled = {
+  exclude?: never;
+  enabled?: boolean;
+};
+
+export type Reasoning = (ReasoningEffort | ReasoningMaxTokens) &
+  (ReasoningExclude | ReasoningEnabled);
+
+export type ReasoningDetails = {
+  type: "reasoning.text" | "<unknown>";
+  text?: string;
+  signature?: string;
+  format?: string;
+  index?: number;
+};
+
+/**
+ * A (openrouter-specific) stream chunk possibly containing reasoning tokens.
+ */
+export type ChatCompletionChunkChoiceDeltaWithReasoning =
+  OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta & {
+    reasoning?: string;
+    reasoning_details?: ReasoningDetails[];
+  };
+
+// /**
+//  * A chat completion message with extra reasoning tokens.
+//  */
+// export interface ChatCompletionMessageWithReasoning
+//   extends OpenAI.Chat.Completions.ChatCompletionMessage {
+//   reasoning?: string;
+// }
+
+// Util function to extract reasoning tokens
+
+export function choiceDeltaExtractReasoning(
+  delta: ChatCompletionChunkChoiceDeltaWithReasoning
+): string | undefined {
+  if (delta.reasoning) {
+    return delta.reasoning;
+  }
+
+  if (delta.reasoning_details) {
+    let reasoning = "";
+    for (const details of delta.reasoning_details) {
+      if (details.type !== "reasoning.text") {
+        throw new Error(`unexpected details.type: ${details.type}`);
+      }
+      if (details.text) {
+        if (typeof details.text !== "string") {
+          throw new Error(
+            `unexpected typeof details.text: ${typeof details.text}`
+          );
+        }
+        reasoning += details.text;
+      }
+    }
+    return reasoning;
+  }
+
+  return undefined;
+}

package/src/agent/openAILLM.ts

@@ -1,5 +1,51 @@
-import { ILLM, XALIA_APP_HEADER } from "./llm";
+import { strict as assert } from "assert";
+
+import {
+  ILLM,
+  MessageParam,
+  ToolDescriptor,
+  XALIA_APP_HEADER,
+  Completion,
+  Choice,
+  MessageToolCall,
+  Message,
+} from "./llm";
 import { OpenAI } from "openai";
+import {
+  ChatCompletion,
+  ChatCompletionChoice,
+  ChatCompletionMessage,
+  ChatCompletionMessageToolCall,
+} from "./openAI";
+
+function toolCallFromOpenAi(
+  toolCall: ChatCompletionMessageToolCall
+): MessageToolCall {
+  assert(toolCall.type === "function");
+  return toolCall;
+}
+
+function messageFromOpenAi(message: ChatCompletionMessage): Message {
+  return {
+    ...message,
+    tool_calls: message.tool_calls?.map(toolCallFromOpenAi),
+  };
+}
+
+function choicesFromOpenAI(choice: ChatCompletionChoice): Choice {
+  return {
+    ...choice,
+    message: messageFromOpenAi(choice.message),
+    // tool_calls: choice.tool_calls?.map(toolCallFromOpenAi),
+  };
+}
+
+function completionFromOpenAI(completion: ChatCompletion): Completion {
+  return {
+    ...completion,
+    choices: completion.choices.map(choicesFromOpenAI),
+  };
+}
 
 export class OpenAILLM implements ILLM {
   private readonly openai: OpenAI;
@@ -28,10 +74,10 @@ export class OpenAILLM implements ILLM {
   }
 
   public async getConversationResponse(
-    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
-    tools?: OpenAI.Chat.Completions.ChatCompletionTool[],
+    messages: MessageParam[],
+    tools?: ToolDescriptor[],
     onMessage?: (msg: string, end: boolean) => Promise<void>
-  ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+  ): Promise<Completion> {
     const completion = await this.openai.chat.completions.create({
       model: this.model,
       messages,
@@ -43,6 +89,7 @@ export class OpenAILLM implements ILLM {
         await onMessage(message.content, true);
       }
     }
-    return completion;
+
+    return completionFromOpenAI(completion);
   }
 }

package/src/agent/openAILLMStreaming.ts

@@ -5,20 +5,28 @@ import { getLogger } from "@xalia/xmcp/sdk";
 
 import {
   ILLM,
-  ChatCompletionChunkChoiceDeltaWithReasoning,
-  ChatCompletionMessageWithReasoning,
-  Reasoning,
-  choiceDeltaExtractReasoning,
+  Message,
   XALIA_APP_HEADER,
+  MessageToolCall,
+  Choice,
+  Completion,
+  MessageParam,
+  ToolDescriptor,
 } from "./llm";
 
+import {
+  Reasoning,
+  ChatCompletionChunkChoiceDeltaWithReasoning,
+  choiceDeltaExtractReasoning,
+} from "./openAI";
+
 const logger = getLogger();
 
 function initialToolCallFunction(
   deltaFn:
     | OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall.Function
     | undefined
-): OpenAI.Chat.Completions.ChatCompletionMessageToolCall.Function {
+): OpenAI.Chat.Completions.ChatCompletionMessageFunctionToolCall.Function {
   //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
   //     arguments?: string;
   //     name?: string;
@@ -38,7 +46,7 @@ function initialToolCallFunction(
 }
 
 function updateToolCallFunction(
-  existingFn: OpenAI.Chat.Completions.ChatCompletionMessageToolCall.Function,
+  existingFn: OpenAI.Chat.Completions.ChatCompletionMessageFunctionToolCall.Function, // eslint-disable-line
   deltaFn: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall.Function // eslint-disable-line
 ) {
   //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
@@ -65,7 +73,7 @@ function updateToolCallFunction(
 
 function initialToolCall(
   delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall
-): OpenAI.Chat.Completions.ChatCompletionMessageToolCall {
+): MessageToolCall {
   return {
     id: delta.id || "",
     function: initialToolCallFunction(delta.function),
@@ -74,7 +82,7 @@ function initialToolCall(
 }
 
 function updateToolCall(
-  existing: OpenAI.Chat.Completions.ChatCompletionMessageToolCall,
+  existing: MessageToolCall,
   delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall
 ) {
   //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
@@ -110,11 +118,9 @@ function updateToolCall(
 }
 
 function updateToolCalls(
-  toolCalls:
-    | OpenAI.Chat.Completions.ChatCompletionMessageToolCall[]
-    | undefined,
+  toolCalls: MessageToolCall[] | undefined,
   deltaToolCall: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall // eslint-disable-line
-): OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] {
+): MessageToolCall[] {
   //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
   //     index: number;
   //     id?: string;
@@ -149,7 +155,7 @@ function updateToolCalls(
 
 function initializeCompletionMessage(
   delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta
-): OpenAI.Chat.Completions.ChatCompletionMessage {
+): Message {
   assert(delta.role === undefined || delta.role == "assistant");
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   assert(!delta.function_call);
@@ -174,9 +180,7 @@ function initializeCompletionMessage(
   //     tool_calls?: Array<ChatCompletionMessageToolCall>;
   //   }
 
-  let toolCalls:
-    | OpenAI.Chat.Completions.ChatCompletionMessageToolCall[]
-    | undefined = undefined;
+  let toolCalls: MessageToolCall[] | undefined = undefined;
   if (delta.tool_calls) {
     for (const t of delta.tool_calls) {
       toolCalls = updateToolCalls(toolCalls, t);
@@ -194,10 +198,7 @@ function initializeCompletionMessage(
   };
 }
 
-function updateReasoning(
-  message: ChatCompletionMessageWithReasoning,
-  reasoning: string
-) {
+function updateReasoning(message: Message, reasoning: string) {
   if (!message.reasoning) {
     message.reasoning = reasoning;
   } else {
@@ -206,7 +207,7 @@ function updateReasoning(
 }
 
 function updateCompletionMessage(
-  message: ChatCompletionMessageWithReasoning,
+  message: Message,
   delta: ChatCompletionChunkChoiceDeltaWithReasoning
 ) {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -280,7 +281,7 @@ function updateCompletionMessage(
 
 function initializeCompletionChoice(
   chunkChoice: OpenAI.Chat.Completions.ChatCompletionChunk.Choice
-): { choice: OpenAI.Chat.Completions.ChatCompletion.Choice; done: boolean } {
+): { choice: Choice; done: boolean } {
   //   export interface ChatCompletionChunk.Choice {
   //     delta: Choice.Delta;
   //     finish_reason:
@@ -313,7 +314,7 @@ function initializeCompletionChoice(
 }
 
 function updateCompletionChoice(
-  completionChoice: OpenAI.Chat.Completions.ChatCompletion.Choice,
+  completionChoice: Choice,
   chunkChoice: OpenAI.Chat.Completions.ChatCompletionChunk.Choice
 ): boolean {
   //   export interface ChatCompletionChunk.Choice {
@@ -352,7 +353,7 @@ function updateCompletionChoice(
 
 function initializeCompletionChoices(
   chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
-): { choices: OpenAI.Chat.Completions.ChatCompletion.Choice[]; done: boolean } {
+): { choices: Choice[]; done: boolean } {
   // Technically, one choice could be done and the other still have some
   // content to stream.  We keep it simple for now and allow zero or one
   // choice per chunk, which allows us to mark everything as done if any
@@ -361,7 +362,7 @@ function initializeCompletionChoices(
   assert(chunkChoices.length < 2);
 
   let msgDone = false;
-  const choices: OpenAI.Chat.Completions.ChatCompletion.Choice[] = [];
+  const choices: Choice[] = [];
   for (const chunkChoice of chunkChoices) {
     const { choice, done } = initializeCompletionChoice(chunkChoice);
     if (done) {
@@ -374,7 +375,7 @@ function initializeCompletionChoices(
 }
 
 function updateCompletionChoices(
-  completionChoices: OpenAI.Chat.Completions.ChatCompletion.Choice[],
+  completionChoices: Choice[],
   chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
 ): boolean {
   // Technically, one choice could be done and the other still have some
@@ -402,7 +403,7 @@ function updateCompletionChoices(
 
 export function initializeCompletion(
   chunk: OpenAI.Chat.Completions.ChatCompletionChunk
-): { initMessage: OpenAI.Chat.Completions.ChatCompletion; done: boolean } {
+): { initMessage: Completion; done: boolean } {
   //   export interface ChatCompletionChunk {
   //     id: string;
   //     choices: Array<ChatCompletionChunk.Choice>;
@@ -436,6 +437,7 @@ export function initializeCompletion(
       model: chunk.model,
       object: "chat.completion",
       service_tier: chunk.service_tier,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
       system_fingerprint: chunk.system_fingerprint,
       usage: chunk.usage ?? undefined,
     },
@@ -444,7 +446,7 @@ export function initializeCompletion(
 }
 
 export function updateCompletion(
-  completion: OpenAI.Chat.Completions.ChatCompletion,
+  completion: Completion,
   chunk: OpenAI.Chat.Completions.ChatCompletionChunk
 ): boolean {
   //   export interface ChatCompletionChunk {
@@ -474,7 +476,9 @@ export function updateCompletion(
   assert(completion.id === chunk.id);
   assert(completion.model === chunk.model);
   completion.service_tier = completion.service_tier || chunk.service_tier;
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   completion.system_fingerprint =
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     completion.system_fingerprint || chunk.system_fingerprint;
   completion.usage = completion.usage || chunk.usage || undefined;
 
@@ -508,11 +512,11 @@ export class OpenAILLMStreaming implements ILLM {
   }
 
   public async getConversationResponse(
-    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
-    tools?: OpenAI.Chat.Completions.ChatCompletionTool[],
+    messages: MessageParam[],
+    tools?: ToolDescriptor[],
     onMessage?: (msg: string, end: boolean) => Promise<void>,
     onReasoning?: (reasoning: string) => Promise<void>
-  ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+  ): Promise<Completion> {
     const reasoning: Reasoning = {
       effort: "medium",
       enabled: true,
@@ -533,7 +537,7 @@ export class OpenAILLMStreaming implements ILLM {
       throw new Error("not a stream");
     }
 
-    let aggregatedMessage: OpenAI.Chat.Completions.ChatCompletion | undefined;
+    let aggregatedMessage: Completion | undefined;
 
     for await (const chunk of chunks) {
       logger.debug(`[stream] chunk: ${JSON.stringify(chunk)}`);

package/src/agent/repeatLLM.ts

@@ -1,5 +1,4 @@
-import { ILLM } from "./llm";
-import { OpenAI } from "openai";
+import { Choice, Completion, ILLM, MessageParam, ToolDescriptor } from "./llm";
 import { strict as assert } from "assert";
 
 export class RepeatLLM implements ILLM {
@@ -14,14 +13,14 @@ export class RepeatLLM implements ILLM {
   }
 
   public async getConversationResponse(
-    _messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
-    _tools?: OpenAI.Chat.Completions.ChatCompletionTool[],
+    _messages: MessageParam[],
+    _tools?: ToolDescriptor[],
     onMessage?: (msg: string, msgEnd: boolean) => Promise<void>
-  ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+  ): Promise<Completion> {
     await new Promise((r) => setTimeout(r, 1000));
 
     const content = `Message number ${String(this.idx++)}`;
-    const response: OpenAI.Chat.Completions.ChatCompletion.Choice = {
+    const response: Choice = {
       finish_reason: "stop",
       index: 0,
       logprobs: null,

package/src/agent/sudoMcpServerManager.ts

@@ -15,6 +15,11 @@ import {
 } from "@xalia/xmcp/sdk";
 import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
 
+const DEVELOPMENT: boolean = process.env.DEVELOPMENT === "1";
+
+const DEV_MCP_SERVER_URL: string =
+  process.env.DEV_MCP_SERVER_URL || "http://localhost:8000/mcp";
+
 const logger = getLogger();
 
 export const LOCAL_SERVER_URL: string = "http://localhost:5001";
@@ -66,7 +71,7 @@ export class SkillManager extends McpServerManager implements ISkillManager {
   private constructor(
     private apiClient: ApiClient,
     private serverBriefs: SanitizedServerBrief[],
-    private serverBriefsMap: { [serverName: string]: SanitizedServerBrief },
+    private serverBriefsMap: Record<string, SanitizedServerBrief>,
     private toolCache: Map<string, Tool[]>,
     private openUrl: (
       url: string,
@@ -101,6 +106,23 @@ export class SkillManager extends McpServerManager implements ISkillManager {
     // Fetch server list
     const servers = await apiClient.listServers();
 
+    if (DEVELOPMENT) {
+      servers.push(
+        new McpServerBrief(
+          "local_dev",
+          "Local Dev Server",
+          "A local mcp server using streamable-HTTP for development use.  " +
+            `URL: ${DEV_MCP_SERVER_URL}`,
+          false,
+          {},
+          "",
+          null,
+          null,
+          DEV_MCP_SERVER_URL
+        )
+      );
+    }
+
     const [mcpServers, mcpServersMap] = buildServersList(servers);
     return new SkillManager(
       apiClient,
@@ -206,22 +228,32 @@ export class SkillManager extends McpServerManager implements ISkillManager {
     serverName: string,
     enableAll: boolean
   ): Promise<void> {
-    const tools = await this.getServerTools(serverName);
-    const originalName = this.serverBriefsMap[serverName].originalName;
-    const mcpserver = await this.apiClient.getDetails(originalName, "run");
-    const client = new McpClient({
-      name: "@xalia/agent",
-      version: "1.0.0",
-    });
-    await connectServer(
-      client,
-      this.apiClient,
-      mcpserver,
-      this.openUrl,
-      this.authorized_url
-    );
+    const brief = this.serverBriefsMap[serverName];
+    if (brief.url_override) {
+      // Assume no api key for now
+      await this.addMcpServerWithStreamableHTTPUrl(
+        serverName,
+        brief.url_override
+      );
+    } else {
+      const tools = await this.getServerTools(serverName);
+      const originalName = this.serverBriefsMap[serverName].originalName;
+      const mcpserver = await this.apiClient.getDetails(originalName, "run");
+      const client = new McpClient({
+        name: "@xalia/agent",
+        version: "1.0.0",
+      });
+      await connectServer(
+        client,
+        this.apiClient,
+        mcpserver,
+        this.openUrl,
+        this.authorized_url
+      );
+
+      await this.addMcpServerWithClient(client, serverName, tools);
+    }
 
-    await this.addMcpServerWithClient(client, serverName, tools);
     if (enableAll) {
       this.enableAllTools(serverName);
     }

package/src/agent/tools.ts

@@ -1,6 +1,6 @@
-import OpenAI from "openai";
+import { MessageToolCall, ToolDescriptor } from "./llm";
 
-export const temperatureTool: OpenAI.ChatCompletionTool = {
+export const temperatureTool: ToolDescriptor = {
   type: "function",
   function: {
     name: "getCurrentTemperature",
@@ -51,9 +51,7 @@ export const toolCallbacks: {
   },
 };
 
-export function displayToolCall(
-  toolCall: OpenAI.ChatCompletionMessageToolCall
-): void {
+export function displayToolCall(toolCall: MessageToolCall): void {
   console.log(`AGENT: Tool Call: ${toolCall.function.name}`);
   console.log(`       Args: ${toolCall.function.arguments}`);
 }

package/src/chat/client/chatClient.ts

@@ -518,7 +518,8 @@ export class ChatClient implements ITeamManager {
   createNewAgent(
     agentName: string,
     templateName?: string,
-    teamUuid?: string
+    teamUuid?: string,
+    model?: string
   ): void {
     if (this.closed) {
       throw new Error("ChatClient is closed");
@@ -529,6 +530,7 @@ export class ChatClient implements ITeamManager {
         title: agentName,
         template_name: templateName,
         team_uuid: teamUuid,
+        model,
       });
     } catch (error) {
       this.eventHandler.onError(String(error));

package/src/chat/client/sessionClient.ts

@@ -1,4 +1,4 @@
-import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { Tool, Resource } from "@modelcontextprotocol/sdk/types.js";
 import { strict as assert } from "assert";
 import { v4 as uuidv4 } from "uuid";
 
@@ -10,9 +10,13 @@ import {
 } from "@xalia/xmcp/sdk";
 
 import { ISkillManager } from "../../agent/sudoMcpServerManager";
-import { McpServerInfo, McpServerInfoRW } from "../../agent/mcpServerManager";
+import {
+  McpServerInfo,
+  McpServerInfoRW,
+  ResourceContent,
+} from "../../agent/mcpServerManager";
 import { IConversation } from "../../agent/agent";
-import { ChatCompletionMessageParam } from "../../agent/llm";
+import { MessageParam } from "../../agent/llm";
 
 import {
   ClientSessionMessage,
@@ -135,14 +139,15 @@ class RemoteSudoMcpServerManager implements ISkillManager {
   onMcpServerAdded(
     mcpServerName: string,
     tools: Tool[],
-    enabled_tools: string[]
+    enabled_tools: string[],
+    resources: Resource[]
   ) {
     logger.debug(
       `[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
         `, enabled: ${JSON.stringify(enabled_tools)}`
     );
 
-    const mcpServerInfo = new McpServerInfoRW(tools);
+    const mcpServerInfo = new McpServerInfoRW(mcpServerName, tools, resources);
     for (const tool of enabled_tools) {
       mcpServerInfo.enableTool(tool);
     }
@@ -258,7 +263,7 @@ export class SessionClient implements ISessionMessageSender, IConversation {
     return this.smsm;
   }
 
-  public getConversation(): ChatCompletionMessageParam[] {
+  public getConversation(): MessageParam[] {
     throw new Error("unimpl: getConversation");
   }
 
@@ -304,6 +309,37 @@ export class SessionClient implements ISessionMessageSender, IConversation {
     });
   }
 
+  addMcpServerFromUrl(server_name: string, url: string) {
+    this.sendSessionMessage({
+      type: "add_mcp_server_from_url",
+      server_name,
+      url,
+    });
+  }
+
+  async getMcpResource(
+    server_name: string,
+    uri: string
+  ): Promise<ResourceContent[]> {
+    const client_message_id = uuidv4();
+    const resourceP = this.responseHandler.waitForResponse(client_message_id);
+    this.sender.send({
+      type: "get_mcp_resource",
+      session_id: this.sessionUUID,
+      client_message_id,
+      server_name,
+      uri,
+    });
+
+    const resourceMsg = await resourceP;
+    if (resourceMsg.type !== "mcp_resource") {
+      throw new Error(
+        `unexpected response to resource req: ${JSON.stringify(resourceMsg)}`
+      );
+    }
+    return resourceMsg.contents;
+  }
+
   userMessage(msg?: string, imageB64?: string): void {
     assert(msg || imageB64, "Either message or image must be provided");
 
@@ -450,7 +486,8 @@ export class SessionClient implements ISessionMessageSender, IConversation {
         this.smsm.onMcpServerAdded(
           message.server_name,
           message.tools,
-          message.enabled_tools
+          message.enabled_tools,
+          message.resources
         );
         break;
       case "mcp_server_removed":
@@ -482,6 +519,9 @@ export class SessionClient implements ISessionMessageSender, IConversation {
       case "user_removed":
         this.participants.delete(message.user_uuid);
         break;
+
+      // Responses to requests which can be awaited
+      case "mcp_resource":
       case "session_shared":
         this.responseHandler.onMessage(message);
         break;