hermes-web-ui 0.3.7 → 0.4.0

package/dist/server/routes/update.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateRoutes = void 0;
+const router_1 = __importDefault(require("@koa/router"));
+exports.updateRoutes = new router_1.default();
+exports.updateRoutes.post('/api/hermes/update', async (ctx) => {
+    const isWin = process.platform === 'win32';
+    const cmd = isWin
+        ? 'cmd /c npm install -g hermes-web-ui@latest'
+        : 'npm install -g hermes-web-ui@latest';
+    try {
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const output = execSync(cmd, {
+            encoding: 'utf-8',
+            timeout: 120000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        ctx.body = { success: true, message: output.trim() };
+        setTimeout(() => {
+            const { spawn } = require('child_process');
+            spawn(isWin ? 'cmd' : 'sh', isWin ? ['/c', 'hermes-web-ui restart'] : ['-c', 'hermes-web-ui restart'], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            }).unref();
+            process.exit(0);
+        }, 2000);
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { success: false, message: err.stderr || err.message };
+    }
+});

package/dist/server/routes/upload.js

@@ -23,28 +23,58 @@ exports.uploadRoutes.post('/upload', async (ctx) => {
         return;
     }
     await (0, promises_1.mkdir)(config_1.config.uploadDir, { recursive: true });
-    // Read raw body
+    // Read raw body as Buffer
     const chunks = [];
     for await (const chunk of ctx.req)
         chunks.push(chunk);
-    const body = Buffer.concat(chunks).toString('latin1');
-    const parts = body.split(boundary).slice(1, -1);
+    const raw = Buffer.concat(chunks);
+    const boundaryBuf = Buffer.from(boundary);
+    const parts = splitMultipart(raw, boundaryBuf);
     const results = [];
     for (const part of parts) {
-        const headerEnd = part.indexOf('\r\n\r\n');
+        const headerEnd = part.indexOf(Buffer.from('\r\n\r\n'));
         if (headerEnd === -1)
             continue;
-        const header = part.substring(0, headerEnd);
-        const data = part.substring(headerEnd + 4, part.length - 2);
-        const filenameMatch = header.match(/filename="([^"]+)"/);
-        if (!filenameMatch)
-            continue;
-        const filename = filenameMatch[1];
+        const headerBuf = part.subarray(0, headerEnd);
+        const header = headerBuf.toString('utf-8');
+        const data = part.subarray(headerEnd + 4, part.length - 2);
+        // Try RFC 5987 filename* first, fall back to filename
+        let filename = '';
+        const filenameStarMatch = header.match(/filename\*=UTF-8''(.+)/i);
+        if (filenameStarMatch) {
+            filename = decodeURIComponent(filenameStarMatch[1]);
+        }
+        else {
+            const filenameMatch = header.match(/filename="([^"]+)"/);
+            if (!filenameMatch)
+                continue;
+            filename = filenameMatch[1];
+        }
         const ext = filename.includes('.') ? '.' + filename.split('.').pop() : '';
         const savedName = (0, crypto_1.randomBytes)(8).toString('hex') + ext;
         const savedPath = `${config_1.config.uploadDir}/${savedName}`;
-        await (0, promises_1.writeFile)(savedPath, Buffer.from(data, 'binary'));
+        await (0, promises_1.writeFile)(savedPath, data);
         results.push({ name: filename, path: savedPath });
     }
     ctx.body = { files: results };
 });
+/**
+ * Split a multipart Buffer by boundary, returning part Buffers.
+ * Avoids string decoding so multi-byte characters (e.g. Chinese filenames) are preserved.
+ */
+function splitMultipart(raw, boundary) {
+    const parts = [];
+    let start = 0;
+    while (true) {
+        const idx = raw.indexOf(boundary, start);
+        if (idx === -1)
+            break;
+        if (start > 0) {
+            // Skip the \r\n after boundary
+            const partStart = start + 2;
+            parts.push(raw.subarray(partStart, idx));
+        }
+        start = idx + boundary.length;
+    }
+    return parts;
+}

package/dist/server/services/auth.js

@@ -46,7 +46,7 @@ async function authMiddleware(token) {
             return;
         }
         // Skip non-API paths (static files, health check, SPA)
-        const path = ctx.path;
+        const path = ctx.path.toLowerCase();
         if (path === '/health' ||
             (!path.startsWith('/api') && !path.startsWith('/v1') && path !== '/webhook')) {
             await next();

package/dist/server/services/gateway-bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare function getGatewayManagerInstance(): any;
+export declare function initGatewayManager(): Promise<void>;

package/dist/server/services/gateway-bootstrap.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGatewayManagerInstance = getGatewayManagerInstance;
+exports.initGatewayManager = initGatewayManager;
+let gatewayManager = null;
+function getGatewayManagerInstance() {
+    return gatewayManager;
+}
+async function initGatewayManager() {
+    const { GatewayManager } = await Promise.resolve().then(() => __importStar(require('./hermes/gateway-manager')));
+    const { getActiveProfileName } = await Promise.resolve().then(() => __importStar(require('./hermes/hermes-profile')));
+    const { setGatewayManager } = await Promise.resolve().then(() => __importStar(require('../routes/hermes/gateways')));
+    const activeProfile = getActiveProfileName();
+    gatewayManager = new GatewayManager(activeProfile);
+    setGatewayManager(gatewayManager);
+    await gatewayManager.detectAllOnStartup();
+    await gatewayManager.startAll();
+}

package/dist/server/services/group-chat/coordinator.d.ts

@@ -0,0 +1,14 @@
+import * as roomsDb from './rooms-db';
+export type AgentStatus = 'thinking' | 'responding' | 'done' | 'error';
+export interface CoordinatorCallbacks {
+    onDelta: (roomId: string, agentName: string, text: string) => void;
+    onAgentStatus: (roomId: string, agentName: string, status: AgentStatus) => void;
+    onAgentComplete: (roomId: string, agentName: string, message: roomsDb.RoomMessage) => void;
+    onAgentError: (roomId: string, agentName: string, error: string) => void;
+}
+export declare function parseMentions(text: string): string[];
+export declare function buildAgentContext(roomId: string, agentName: string, agents: roomsDb.RoomAgent[], maxMessages?: number): Array<{
+    role: string;
+    content: string;
+}>;
+export declare function processMessage(roomId: string, content: string, callbacks: CoordinatorCallbacks): Promise<void>;

package/dist/server/services/group-chat/coordinator.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMentions = parseMentions;
+exports.buildAgentContext = buildAgentContext;
+exports.processMessage = processMessage;
+const roomsDb = __importStar(require("./rooms-db"));
+const gateways_1 = require("../../routes/hermes/gateways");
+// ---------------------------------------------------------------------------
+// @mention parsing
+// ---------------------------------------------------------------------------
+function parseMentions(text) {
+    const pattern = /@(\w+)/g;
+    const mentions = [];
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        mentions.push(match[1]);
+    }
+    return [...new Set(mentions)];
+}
+// ---------------------------------------------------------------------------
+// Context building
+// ---------------------------------------------------------------------------
+function buildAgentContext(roomId, agentName, agents, maxMessages = 20) {
+    const recentMessages = roomsDb.getRecentContext(roomId, agentName, maxMessages);
+    const context = [];
+    // Add role prompt
+    const agent = agents.find((a) => a.agent_name === agentName);
+    if (agent?.role_prompt) {
+        context.push({ role: 'system', content: agent.role_prompt });
+    }
+    else {
+        context.push({
+            role: 'system',
+            content: `You are ${agentName}, participating in a group chat. Respond concisely. You can see messages where you were @mentioned and public messages (no @mentions).`,
+        });
+    }
+    // Convert recent messages (DESC from DB → reverse to ASC chronological)
+    for (const msg of recentMessages.reverse()) {
+        if (msg.role === 'user') {
+            context.push({ role: 'user', content: msg.content });
+        }
+        else if (msg.role === 'assistant' && msg.agent_name) {
+            context.push({ role: 'assistant', content: `[${msg.agent_name}] ${msg.content}` });
+        }
+    }
+    return context;
+}
+// ---------------------------------------------------------------------------
+// Main: process a user message
+// ---------------------------------------------------------------------------
+async function processMessage(roomId, content, callbacks) {
+    const mentions = parseMentions(content);
+    const agents = roomsDb.getRoomAgents(roomId);
+    if (agents.length === 0)
+        return;
+    // Determine responding agents
+    const respondingAgents = mentions.length > 0
+        ? agents.filter((a) => mentions.includes(a.agent_name))
+        : agents;
+    if (respondingAgents.length === 0)
+        return;
+    // Store user message
+    const round = roomsDb.getLatestRound(roomId);
+    roomsDb.addMessage({
+        room_id: roomId,
+        role: 'user',
+        content,
+        mentions,
+        round,
+    });
+    // Fan out to agents in parallel
+    const tasks = respondingAgents.map((agent) => invokeAgent(roomId, agent, round, content, callbacks).catch(() => { }));
+    await Promise.allSettled(tasks);
+}
+// ---------------------------------------------------------------------------
+// Invoke a single agent
+// ---------------------------------------------------------------------------
+async function invokeAgent(roomId, agent, round, userMessage, callbacks) {
+    const agentName = agent.agent_name;
+    let upstream = '';
+    let apiKey = null;
+    try {
+        callbacks.onAgentStatus(roomId, agentName, 'thinking');
+        // Resolve gateway URL and API key for this agent's profile
+        const manager = (0, gateways_1.getGatewayManager)();
+        if (!manager)
+            throw new Error('GatewayManager not initialized');
+        upstream = manager.getUpstream(agent.profile);
+        apiKey = manager.getApiKey(agent.profile);
+        // Build conversation context
+        const agents = roomsDb.getRoomAgents(roomId);
+        const context = buildAgentContext(roomId, agentName, agents);
+        // Start run via Hermes API Server
+        const headers = { 'Content-Type': 'application/json' };
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        const body = { input: userMessage };
+        if (context.length > 0)
+            body.conversation_history = context;
+        if (agent.session_id)
+            body.session_id = agent.session_id;
+        const runRes = await fetch(`${upstream}/v1/runs`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(120_000),
+        });
+        if (!runRes.ok) {
+            const errText = await runRes.text();
+            throw new Error(`Hermes API error ${runRes.status}: ${errText.slice(0, 200)}`);
+        }
+        const runData = await runRes.json();
+        const runId = runData.run_id || runData.id;
+        if (!runId)
+            throw new Error('No run_id returned from Hermes API');
+        // Persist session_id for subsequent messages
+        if (runData.session_id && runData.session_id !== agent.session_id) {
+            roomsDb.updateRoomAgentSession(roomId, agentName, runData.session_id);
+        }
+        callbacks.onAgentStatus(roomId, agentName, 'responding');
+        // Stream SSE events
+        const sseHeaders = {};
+        if (apiKey)
+            sseHeaders['Authorization'] = `Bearer ${apiKey}`;
+        const sseRes = await fetch(`${upstream}/v1/runs/${runId}/events`, {
+            headers: sseHeaders,
+            signal: AbortSignal.timeout(300_000),
+        });
+        if (!sseRes.ok || !sseRes.body) {
+            throw new Error(`Failed to stream events: ${sseRes.status}`);
+        }
+        let fullContent = '';
+        const reader = sseRes.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (data === '[DONE]')
+                        continue;
+                    try {
+                        const event = JSON.parse(data);
+                        if (event.event === 'message.delta' && event.delta) {
+                            fullContent += event.delta;
+                            callbacks.onDelta(roomId, agentName, event.delta);
+                        }
+                        if (event.event === 'run.completed' || event.event === 'run.failed') {
+                            // If delta contained in completed event
+                            if (event.event === 'run.completed' && event.response) {
+                                fullContent = event.response;
+                            }
+                        }
+                    }
+                    catch {
+                        // skip malformed JSON
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (!fullContent)
+            fullContent = '(no response)';
+        // Store completed response
+        const msg = roomsDb.addMessage({
+            room_id: roomId,
+            role: 'assistant',
+            agent_name: agentName,
+            content: fullContent,
+            round,
+        });
+        callbacks.onAgentStatus(roomId, agentName, 'done');
+        callbacks.onAgentComplete(roomId, agentName, msg);
+    }
+    catch (err) {
+        const errorMsg = err?.message || 'Unknown error';
+        callbacks.onAgentStatus(roomId, agentName, 'error');
+        callbacks.onAgentError(roomId, agentName, errorMsg);
+        roomsDb.addMessage({
+            room_id: roomId,
+            role: 'system',
+            agent_name: agentName,
+            content: `Error: ${errorMsg}`,
+            round,
+        });
+    }
+}

package/dist/server/services/group-chat/index.d.ts

@@ -0,0 +1,5 @@
+import { Server as SocketIOServer } from 'socket.io';
+import type { Server as HttpServer } from 'http';
+export declare function setupGroupChatSocketIO(httpServer: HttpServer): SocketIOServer;
+export declare function getGroupChatIO(): SocketIOServer | null;
+export declare function disconnectGroupChatIO(): void;

package/dist/server/services/group-chat/index.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGroupChatSocketIO = setupGroupChatSocketIO;
+exports.getGroupChatIO = getGroupChatIO;
+exports.disconnectGroupChatIO = disconnectGroupChatIO;
+const socket_io_1 = require("socket.io");
+const auth_1 = require("../auth");
+const roomsDb = __importStar(require("./rooms-db"));
+const coordinator = __importStar(require("./coordinator"));
+let io = null;
+function setupGroupChatSocketIO(httpServer) {
+    io = new socket_io_1.Server(httpServer, {
+        path: '/socket.io/group-chat',
+        cors: { origin: '*' },
+    });
+    // Auth middleware
+    io.use(async (socket, next) => {
+        const authToken = await (0, auth_1.getToken)();
+        if (authToken) {
+            const token = socket.handshake.auth.token || socket.handshake.query.token;
+            if (token !== authToken) {
+                return next(new Error('Unauthorized'));
+            }
+        }
+        next();
+    });
+    io.on('connection', (socket) => {
+        let currentRoom = null;
+        socket.on('room:join', async (roomId) => {
+            if (currentRoom) {
+                socket.leave(currentRoom);
+            }
+            currentRoom = roomId;
+            socket.join(roomId);
+            const messages = roomsDb.getRoomMessages(roomId, 100);
+            const agents = roomsDb.getRoomAgents(roomId);
+            socket.emit('room:history', { roomId, messages, agents });
+        });
+        socket.on('room:leave', (roomId) => {
+            socket.leave(roomId);
+            if (currentRoom === roomId)
+                currentRoom = null;
+        });
+        socket.on('room:message', async (data) => {
+            if (!currentRoom || currentRoom !== data.roomId)
+                return;
+            if (!data.content?.trim())
+                return;
+            const { roomId, content } = data;
+            // Process via coordinator (stores user message internally)
+            await coordinator.processMessage(roomId, content, {
+                onDelta(rId, agentName, text) {
+                    io.to(rId).emit('message:delta', { roomId: rId, agentName, text });
+                },
+                onAgentStatus(rId, agentName, status) {
+                    io.to(rId).emit('agent:status', { roomId: rId, agentName, status });
+                },
+                onAgentComplete(rId, agentName, message) {
+                    io.to(rId).emit('room:message', { roomId: rId, message });
+                },
+                onAgentError(rId, agentName, error) {
+                    io.to(rId).emit('agent:status', { roomId: rId, agentName, status: 'error', error });
+                },
+            });
+        });
+        socket.on('disconnect', () => {
+            if (currentRoom) {
+                socket.leave(currentRoom);
+            }
+        });
+    });
+    return io;
+}
+function getGroupChatIO() {
+    return io;
+}
+function disconnectGroupChatIO() {
+    if (io) {
+        io.disconnectSockets();
+        io = null;
+    }
+}

package/dist/server/services/group-chat/rooms-db.d.ts

@@ -0,0 +1,56 @@
+export interface Room {
+    id: string;
+    name: string;
+    settings: string;
+    created_at: number;
+    updated_at: number;
+}
+export interface RoomAgent {
+    room_id: string;
+    agent_name: string;
+    profile: string;
+    session_id: string;
+    role_prompt: string;
+}
+export interface RoomMessage {
+    id: string;
+    room_id: string;
+    role: 'user' | 'assistant' | 'system';
+    agent_name: string;
+    content: string;
+    mentions: string;
+    round: number;
+    created_at: number;
+}
+export interface NewRoomMessage {
+    room_id: string;
+    role: string;
+    agent_name?: string;
+    content: string;
+    mentions?: string[];
+    round?: number;
+}
+export declare function createRoom(name: string): Room;
+export declare function listRooms(): Room[];
+export declare function getRoom(roomId: string): Room | null;
+export declare function updateRoom(roomId: string, updates: Partial<Pick<Room, 'name' | 'settings'>>): boolean;
+export declare function deleteRoom(roomId: string): boolean;
+export declare function addRoomAgent(roomId: string, agent: {
+    agent_name: string;
+    profile: string;
+    role_prompt?: string;
+}): RoomAgent | null;
+export declare function removeRoomAgent(roomId: string, agentName: string): boolean;
+export declare function getRoomAgents(roomId: string): RoomAgent[];
+export declare function updateRoomAgentSession(roomId: string, agentName: string, sessionId: string): void;
+export declare function addMessage(msg: NewRoomMessage): RoomMessage;
+export declare function getRoomMessages(roomId: string, limit?: number, offset?: number): RoomMessage[];
+export declare function getLatestRound(roomId: string): number;
+/**
+ * Get recent context messages relevant to a specific agent.
+ * Returns messages where:
+ *   - mentions is empty (public message, no @mentions)
+ *   - mentions includes agentName
+ *   - message is FROM this agent
+ */
+export declare function getRecentContext(roomId: string, agentName: string, limit?: number): RoomMessage[];