mirror of
https://github.com/wassname/HumanAgent-MCP.git
synced 2026-09-09 11:14:27 +08:00
Eliminate duplicate pendingHumanRequests system - use ChatManager only
- Removed pendingHumanRequests Map completely - Added findPendingRequest() method to ChatManager for cross-session lookups - Created minimal requestResolvers Map only for Promise resolve/reject functions - Replaced all 9 calls to old system with ChatManager equivalents: * /response endpoint now uses ChatManager.findPendingRequest() * Timeout cleanup uses ChatManager.removePendingRequest() * Request storage uses ChatManager.addPendingRequest() only * respondToHumanRequest() and resolvePendingRequest() updated - No more duplicate data storage - single source of truth in ChatManager - All functionality preserved, cleaner architecture
This commit is contained in:
B Harper
Vendored
+438
-1103
File diff suppressed because it is too large
Load Diff
@@ -6,3 +6,9 @@
|
||||
2025-10-24T00:12:59.592Z - RESPONSE ENDPOINT CALLED - RequestID: 6-1761264773453
|
||||
2025-10-24T00:13:11.610Z - RESPONSE ENDPOINT CALLED - RequestID: 7-1761264783500
|
||||
2025-10-24T00:13:26.236Z - RESPONSE ENDPOINT CALLED - RequestID: 8-1761264795145
|
||||
2025-10-24T00:27:30.026Z - RESPONSE ENDPOINT CALLED - RequestID: 3-1761265487845
|
||||
2025-10-24T00:29:45.556Z - RESPONSE ENDPOINT CALLED - RequestID: 4-1761265750949
|
||||
2025-10-24T00:30:12.657Z - RESPONSE ENDPOINT CALLED - RequestID: 5-1761265789274
|
||||
2025-10-24T00:43:00.103Z - RESPONSE ENDPOINT CALLED - RequestID: 3-1761266557759
|
||||
2025-10-24T00:43:44.783Z - RESPONSE ENDPOINT CALLED - RequestID: 4-1761266590985
|
||||
2025-10-24T00:44:34.053Z - RESPONSE ENDPOINT CALLED - RequestID: 5-1761266631221
|
||||
|
||||
@@ -131,6 +131,21 @@ export class ChatManager {
|
||||
return { requestId, data };
|
||||
}
|
||||
|
||||
/**
|
||||
* Find a pending request by ID across all sessions
|
||||
*/
|
||||
findPendingRequest(requestId: string): { sessionId: string; data: any } | null {
|
||||
for (const [sessionId, session] of this.sessions.entries()) {
|
||||
if (session.pendingRequests.has(requestId)) {
|
||||
return {
|
||||
sessionId,
|
||||
data: session.pendingRequests.get(requestId)
|
||||
};
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get session state summary
|
||||
*/
|
||||
|
||||
@@ -1,64 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Extension Bridge for MCP
|
||||
* This script acts as a bridge between VS Code's MCP client and the extension's internal MCP server
|
||||
* It uses VS Code's extension API to communicate with the running extension
|
||||
*/
|
||||
|
||||
import * as vscode from 'vscode';
|
||||
|
||||
class ExtensionBridge {
|
||||
async start() {
|
||||
// This script will be executed when VS Code connects to the MCP server
|
||||
// We need to find a way to communicate with the extension's internal McpServer
|
||||
|
||||
// For now, use stdio communication
|
||||
process.stdin.on('data', async (data) => {
|
||||
try {
|
||||
const input = data.toString().trim();
|
||||
if (!input) {
|
||||
return;
|
||||
}
|
||||
|
||||
const message = JSON.parse(input);
|
||||
|
||||
// Try to get the extension and forward the message
|
||||
const extension = vscode.extensions.getExtension('your-extension-id');
|
||||
if (extension && extension.isActive) {
|
||||
// This won't work because this script runs in a separate process
|
||||
// We need a different approach
|
||||
}
|
||||
|
||||
// For now, return an error
|
||||
const errorResponse = {
|
||||
id: message.id,
|
||||
type: 'response',
|
||||
error: {
|
||||
code: -32603,
|
||||
message: 'Extension bridge not implemented yet'
|
||||
}
|
||||
};
|
||||
process.stdout.write(JSON.stringify(errorResponse) + '\n');
|
||||
} catch (error) {
|
||||
const errorResponse = {
|
||||
id: null,
|
||||
type: 'response',
|
||||
error: {
|
||||
code: -32700,
|
||||
message: 'Parse error',
|
||||
data: error instanceof Error ? error.message : String(error)
|
||||
}
|
||||
};
|
||||
process.stdout.write(JSON.stringify(errorResponse) + '\n');
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Start the bridge
|
||||
const bridge = new ExtensionBridge();
|
||||
bridge.start().catch((error) => {
|
||||
console.error('Failed to start extension bridge:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -1,233 +0,0 @@
|
||||
import * as vscode from 'vscode';
|
||||
import * as cp from 'child_process';
|
||||
import * as path from 'path';
|
||||
import { EventEmitter } from 'events';
|
||||
import { HumanAgentSession, ChatMessage, McpTool } from './types';
|
||||
|
||||
export class McpServerClient extends EventEmitter {
|
||||
private serverProcess: cp.ChildProcess | null = null;
|
||||
private isConnected = false;
|
||||
private extensionPath: string;
|
||||
private pendingRequests = new Map<string, { resolve: Function; reject: Function }>();
|
||||
private requestId = 1;
|
||||
|
||||
constructor(extensionPath: string) {
|
||||
super();
|
||||
this.extensionPath = extensionPath;
|
||||
}
|
||||
|
||||
async start(): Promise<void> {
|
||||
if (this.isConnected) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const serverPath = path.join(this.extensionPath, 'dist', 'mcpStandalone.js');
|
||||
|
||||
console.log('Starting MCP server client:', serverPath);
|
||||
|
||||
this.serverProcess = cp.spawn('node', [serverPath], {
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
detached: false,
|
||||
env: {
|
||||
...process.env,
|
||||
NODE_ENV: 'production'
|
||||
}
|
||||
});
|
||||
|
||||
this.serverProcess.on('spawn', () => {
|
||||
console.log('MCP server process spawned for client connection');
|
||||
this.isConnected = true;
|
||||
this.emit('connected');
|
||||
});
|
||||
|
||||
this.serverProcess.on('error', (error) => {
|
||||
console.error('MCP server client process error:', error);
|
||||
this.isConnected = false;
|
||||
this.emit('error', error);
|
||||
});
|
||||
|
||||
this.serverProcess.on('exit', (code, signal) => {
|
||||
console.log(`MCP server client process exited with code ${code}, signal ${signal}`);
|
||||
this.isConnected = false;
|
||||
this.emit('disconnected');
|
||||
});
|
||||
|
||||
// Handle server responses
|
||||
if (this.serverProcess.stdout) {
|
||||
this.serverProcess.stdout.on('data', (data) => {
|
||||
this.handleServerResponse(data.toString());
|
||||
});
|
||||
}
|
||||
|
||||
// Give the process a moment to start
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
} catch (error) {
|
||||
console.error('Failed to start MCP server client:', error);
|
||||
this.isConnected = false;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async stop(): Promise<void> {
|
||||
if (!this.isConnected || !this.serverProcess) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
console.log('Stopping MCP server client...');
|
||||
|
||||
// Try graceful shutdown first
|
||||
this.serverProcess.kill('SIGTERM');
|
||||
|
||||
// Wait for graceful shutdown
|
||||
await new Promise<void>((resolve) => {
|
||||
const timeout = setTimeout(() => {
|
||||
// Force kill if graceful shutdown didn't work
|
||||
if (this.serverProcess && !this.serverProcess.killed) {
|
||||
console.log('Force killing MCP server client process...');
|
||||
this.serverProcess.kill('SIGKILL');
|
||||
}
|
||||
resolve();
|
||||
}, 5000);
|
||||
|
||||
if (this.serverProcess) {
|
||||
this.serverProcess.on('exit', () => {
|
||||
clearTimeout(timeout);
|
||||
resolve();
|
||||
});
|
||||
} else {
|
||||
clearTimeout(timeout);
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
|
||||
this.isConnected = false;
|
||||
this.serverProcess = null;
|
||||
} catch (error) {
|
||||
console.error('Failed to stop MCP server client:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
private handleServerResponse(data: string): void {
|
||||
try {
|
||||
const lines = data.trim().split('\n');
|
||||
for (const line of lines) {
|
||||
if (line.trim()) {
|
||||
const response = JSON.parse(line);
|
||||
|
||||
if (response.id && this.pendingRequests.has(response.id)) {
|
||||
const { resolve, reject } = this.pendingRequests.get(response.id)!;
|
||||
this.pendingRequests.delete(response.id);
|
||||
|
||||
if (response.error) {
|
||||
reject(new Error(response.error.message || 'Server error'));
|
||||
} else {
|
||||
resolve(response.result);
|
||||
}
|
||||
} else {
|
||||
// Handle server events/notifications
|
||||
this.handleServerEvent(response);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to parse server response:', error);
|
||||
}
|
||||
}
|
||||
|
||||
private handleServerEvent(event: any): void {
|
||||
// Handle server-sent events (like session updates, new messages, etc.)
|
||||
switch (event.method) {
|
||||
case 'session/created':
|
||||
this.emit('session-created', event.params);
|
||||
break;
|
||||
case 'message/received':
|
||||
this.emit('message-received', event.params);
|
||||
break;
|
||||
case 'message/sent':
|
||||
this.emit('message-sent', event.params);
|
||||
break;
|
||||
case 'human/awaiting-response':
|
||||
this.emit('awaiting-human-response', event.params);
|
||||
break;
|
||||
case 'server/started':
|
||||
console.log('MCP server started:', event.params);
|
||||
break;
|
||||
default:
|
||||
console.log('Unknown server event:', event);
|
||||
}
|
||||
}
|
||||
|
||||
private async sendRequest(method: string, params?: any): Promise<any> {
|
||||
if (!this.isConnected || !this.serverProcess?.stdin) {
|
||||
throw new Error('MCP server client not connected');
|
||||
}
|
||||
|
||||
const id = (this.requestId++).toString();
|
||||
const request = {
|
||||
jsonrpc: '2.0',
|
||||
id,
|
||||
method,
|
||||
params: params || {}
|
||||
};
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
this.pendingRequests.set(id, { resolve, reject });
|
||||
|
||||
// Set timeout for request
|
||||
setTimeout(() => {
|
||||
if (this.pendingRequests.has(id)) {
|
||||
this.pendingRequests.delete(id);
|
||||
reject(new Error(`Request timeout: ${method}`));
|
||||
}
|
||||
}, 10000);
|
||||
|
||||
this.serverProcess!.stdin!.write(JSON.stringify(request) + '\n');
|
||||
});
|
||||
}
|
||||
|
||||
// Public API methods using MCP protocol
|
||||
async getAllSessions(): Promise<HumanAgentSession[]> {
|
||||
const response = await this.sendRequest('chat/list-sessions', {});
|
||||
return response.sessions || [];
|
||||
}
|
||||
|
||||
async createSession(name: string): Promise<HumanAgentSession> {
|
||||
const response = await this.sendRequest('chat/create-session', { name });
|
||||
return response.session;
|
||||
}
|
||||
|
||||
async sendMessage(sessionId: string, content: string): Promise<ChatMessage> {
|
||||
const response = await this.sendRequest('chat/send', { sessionId, content });
|
||||
return response.message;
|
||||
}
|
||||
|
||||
async sendToHuman(message: string, context?: string, sessionId?: string): Promise<string> {
|
||||
const response = await this.sendRequest('tools/call', {
|
||||
name: 'HumanAgent_Chat',
|
||||
arguments: { message, context, sessionId }
|
||||
});
|
||||
return response.result?.response || '';
|
||||
}
|
||||
|
||||
async getAvailableTools(): Promise<McpTool[]> {
|
||||
const response = await this.sendRequest('tools/list', {});
|
||||
return response.tools || [];
|
||||
}
|
||||
|
||||
async getPendingRequests(): Promise<any[]> {
|
||||
// This would need to be implemented in the server if needed
|
||||
return [];
|
||||
}
|
||||
|
||||
isServerConnected(): boolean {
|
||||
return this.isConnected;
|
||||
}
|
||||
|
||||
getServerPid(): number | undefined {
|
||||
return this.serverProcess?.pid;
|
||||
}
|
||||
}
|
||||
+42
-73
@@ -97,16 +97,12 @@ export class McpServer extends EventEmitter {
|
||||
private sessionTools: Map<string, Map<string, McpTool>> = new Map(); // Per-session tool configurations
|
||||
private sessionWorkspacePaths: Map<string, string> = new Map(); // Session to workspace path mapping
|
||||
private sessionNames: Map<string, string> = new Map(); // Session friendly names
|
||||
private sessionMessages: Map<string, ChatMessage[]> = new Map(); // Session conversation history - DEPRECATED: Use chatManager
|
||||
// Removed: sessionMessages - now handled by ChatManager
|
||||
private httpServer?: http.Server;
|
||||
private port: number = 3737;
|
||||
private debugLogger: DebugLogger;
|
||||
private pendingHumanRequests: Map<string, {
|
||||
resolve: (value: string) => void;
|
||||
reject: (error: Error) => void;
|
||||
startTime: number;
|
||||
params: HumanAgentChatToolParams;
|
||||
}> = new Map();
|
||||
// Simple Map for resolve/reject functions only - data stored in ChatManager
|
||||
private requestResolvers: Map<string, { resolve: (response: string) => void; reject: (error: Error) => void }> = new Map();
|
||||
private activeSessions: Set<string> = new Set();
|
||||
private sseConnections: Set<http.ServerResponse> = new Set();
|
||||
private conversationToSession: Map<string, string> = new Map(); // Map VS Code conversation IDs to registered session IDs
|
||||
@@ -332,15 +328,8 @@ export class McpServer extends EventEmitter {
|
||||
this.httpServer = undefined;
|
||||
}
|
||||
|
||||
// Clear pending requests with proper cancellation
|
||||
for (const [requestId, request] of this.pendingHumanRequests.entries()) {
|
||||
try {
|
||||
request.reject(new Error('Server shutting down'));
|
||||
} catch (error) {
|
||||
// Ignore rejection errors during shutdown
|
||||
}
|
||||
}
|
||||
this.pendingHumanRequests.clear();
|
||||
// Clear pending requests with proper cancellation - using ChatManager only
|
||||
// Note: ChatManager will handle cleanup automatically on session timeout
|
||||
|
||||
this.isRunning = false;
|
||||
this.debugLogger.close();
|
||||
@@ -351,7 +340,7 @@ export class McpServer extends EventEmitter {
|
||||
// Force stop even if there are errors
|
||||
this.isRunning = false;
|
||||
this.httpServer = undefined;
|
||||
this.pendingHumanRequests.clear();
|
||||
// Removed: pendingHumanRequests.clear() - using ChatManager only
|
||||
this.debugLogger.close();
|
||||
}
|
||||
}
|
||||
@@ -628,19 +617,7 @@ export class McpServer extends EventEmitter {
|
||||
res.end(JSON.stringify({ success: false, error: 'Invalid request body' }));
|
||||
}
|
||||
});
|
||||
} else if (req.method === 'GET' && url.pathname.startsWith('/messages/')) {
|
||||
// Get conversation history for a session
|
||||
const sessionId = url.pathname.split('/')[2];
|
||||
if (!sessionId) {
|
||||
res.statusCode = 400;
|
||||
res.end(JSON.stringify({ success: false, error: 'Session ID required' }));
|
||||
return;
|
||||
}
|
||||
|
||||
const messages = this.getSessionMessages(sessionId);
|
||||
res.statusCode = 200;
|
||||
res.setHeader('Content-Type', 'application/json');
|
||||
res.end(JSON.stringify({ messages, sessionId, count: messages.length }));
|
||||
// Removed: /messages/{sessionId} endpoint - replaced by /sessions/{id}/messages
|
||||
} else if (req.method === 'GET' && url.pathname.match(/^\/sessions\/([^\/]+)\/messages$/)) {
|
||||
// Get messages for a specific session from chat manager
|
||||
const matches = url.pathname.match(/^\/sessions\/([^\/]+)\/messages$/);
|
||||
@@ -702,7 +679,8 @@ export class McpServer extends EventEmitter {
|
||||
type: 'text'
|
||||
};
|
||||
|
||||
this.storeMessage(sessionId, chatMessage);
|
||||
this.chatManager.addMessage(sessionId, chatMessage);
|
||||
this.debugLogger.log('CHAT', `Stored message in ChatManager for session ${sessionId}: ${chatMessage.sender} - ${chatMessage.content.substring(0, 50)}...`);
|
||||
this.broadcastMessageToClients(sessionId, chatMessage);
|
||||
|
||||
// Auto-forwarding removed - both interfaces now use /response endpoint directly
|
||||
@@ -730,12 +708,12 @@ export class McpServer extends EventEmitter {
|
||||
this.debugLogger.log('HTTP', '=== RESPONSE ENDPOINT CALLED ===');
|
||||
this.debugLogger.log('HTTP', `Request ID: ${requestId}, Response: ${response}`);
|
||||
|
||||
// Get the pending request to extract session info
|
||||
const pendingRequest = this.pendingHumanRequests.get(requestId);
|
||||
this.debugLogger.log('HTTP', `Found pending request: ${!!pendingRequest}`);
|
||||
// Get the pending request to extract session info - using ChatManager
|
||||
const pendingRequestInfo = this.chatManager.findPendingRequest(requestId);
|
||||
this.debugLogger.log('HTTP', `Found pending request: ${!!pendingRequestInfo}`);
|
||||
|
||||
if (pendingRequest && pendingRequest.params.sessionId) {
|
||||
this.debugLogger.log('HTTP', `Processing response for session: ${pendingRequest.params.sessionId}`);
|
||||
if (pendingRequestInfo) {
|
||||
this.debugLogger.log('HTTP', `Processing response for session: ${pendingRequestInfo.sessionId}`);
|
||||
|
||||
// Store the user message on server for synchronization
|
||||
const userMessage: ChatMessage = {
|
||||
@@ -747,11 +725,12 @@ export class McpServer extends EventEmitter {
|
||||
};
|
||||
|
||||
this.debugLogger.log('HTTP', `Storing and broadcasting user message to ${this.sseConnections.size} SSE connections`);
|
||||
this.storeMessage(pendingRequest.params.sessionId, userMessage);
|
||||
this.broadcastMessageToClients(pendingRequest.params.sessionId, userMessage);
|
||||
this.chatManager.addMessage(pendingRequestInfo.sessionId, userMessage);
|
||||
this.debugLogger.log('CHAT', `Stored user message in ChatManager for session ${pendingRequestInfo.sessionId}: ${userMessage.content.substring(0, 50)}...`);
|
||||
this.broadcastMessageToClients(pendingRequestInfo.sessionId, userMessage);
|
||||
|
||||
// Remove from ChatManager as well
|
||||
this.chatManager.removePendingRequest(pendingRequest.params.sessionId, requestId);
|
||||
this.chatManager.removePendingRequest(pendingRequestInfo.sessionId, requestId);
|
||||
this.debugLogger.log('HTTP', 'Broadcast completed and pending request removed from ChatManager');
|
||||
} else {
|
||||
this.debugLogger.log('ERROR', `No pending request found for requestId: ${requestId}`);
|
||||
@@ -1475,7 +1454,11 @@ export class McpServer extends EventEmitter {
|
||||
return new Promise((resolve) => {
|
||||
// Set up timeout
|
||||
const timeoutHandle = setTimeout(() => {
|
||||
this.pendingHumanRequests.delete(requestId);
|
||||
// Remove from ChatManager - find which session it belongs to
|
||||
const pendingRequestInfo = this.chatManager.findPendingRequest(requestId);
|
||||
if (pendingRequestInfo) {
|
||||
this.chatManager.removePendingRequest(pendingRequestInfo.sessionId, requestId);
|
||||
}
|
||||
this.debugLogger.log('TOOL', `Request ${requestId} timed out after ${timeout/1000}s`);
|
||||
resolve({
|
||||
id: messageId,
|
||||
@@ -1491,7 +1474,7 @@ export class McpServer extends EventEmitter {
|
||||
const sessionToUse = sessionId || params.sessionId || 'default';
|
||||
this.debugLogger.log('TOOL', `Adding pending request ${requestId} to session: ${sessionToUse}`);
|
||||
this.chatManager.addPendingRequest(sessionToUse, requestId, params);
|
||||
this.pendingHumanRequests.set(requestId, {
|
||||
this.requestResolvers.set(requestId, {
|
||||
resolve: (response: string) => {
|
||||
clearTimeout(timeoutHandle);
|
||||
const responseTime = Date.now() - startTime;
|
||||
@@ -1506,7 +1489,8 @@ export class McpServer extends EventEmitter {
|
||||
timestamp: new Date(),
|
||||
type: 'text'
|
||||
};
|
||||
this.storeMessage(params.sessionId, assistantMessage);
|
||||
this.chatManager.addMessage(params.sessionId, assistantMessage);
|
||||
this.debugLogger.log('CHAT', `Stored assistant message in ChatManager for session ${params.sessionId}: ${assistantMessage.content.substring(0, 50)}...`);
|
||||
this.broadcastMessageToClients(params.sessionId, assistantMessage);
|
||||
}
|
||||
|
||||
@@ -1534,9 +1518,7 @@ export class McpServer extends EventEmitter {
|
||||
message: error.message
|
||||
}
|
||||
});
|
||||
},
|
||||
startTime,
|
||||
params
|
||||
}
|
||||
});
|
||||
|
||||
this.debugLogger.log('TOOL', `Request ${requestId} waiting for human response...`);
|
||||
@@ -1547,10 +1529,10 @@ export class McpServer extends EventEmitter {
|
||||
public respondToHumanRequest(requestId: string, response: string): boolean {
|
||||
this.debugLogger.log('SERVER', `Received human response for request ${requestId}:`, response);
|
||||
|
||||
const pendingRequest = this.pendingHumanRequests.get(requestId);
|
||||
if (pendingRequest) {
|
||||
this.pendingHumanRequests.delete(requestId);
|
||||
pendingRequest.resolve(response);
|
||||
const resolver = this.requestResolvers.get(requestId);
|
||||
if (resolver) {
|
||||
this.requestResolvers.delete(requestId);
|
||||
resolver.resolve(response);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1568,27 +1550,21 @@ export class McpServer extends EventEmitter {
|
||||
return Array.from(this.tools.values());
|
||||
}
|
||||
|
||||
getPendingRequests(): Array<{id: string, params: HumanAgentChatToolParams, startTime: number}> {
|
||||
return Array.from(this.pendingHumanRequests.entries()).map(([id, req]) => ({
|
||||
id,
|
||||
params: req.params,
|
||||
startTime: req.startTime
|
||||
}));
|
||||
}
|
||||
// REMOVED: getPendingRequests - use ChatManager.getPendingRequests() per session instead
|
||||
|
||||
// Method to manually resolve a pending request (for testing)
|
||||
resolvePendingRequest(requestId: string, response: string): boolean {
|
||||
const request = this.pendingHumanRequests.get(requestId);
|
||||
if (request) {
|
||||
// Remove from both places
|
||||
this.pendingHumanRequests.delete(requestId);
|
||||
const resolver = this.requestResolvers.get(requestId);
|
||||
if (resolver) {
|
||||
// Remove resolver
|
||||
this.requestResolvers.delete(requestId);
|
||||
// Find the session ID for this request and remove it from ChatManager
|
||||
for (const sessionId of this.chatManager.getActiveSessions()) {
|
||||
if (this.chatManager.removePendingRequest(sessionId, requestId)) {
|
||||
break;
|
||||
}
|
||||
const pendingRequestInfo = this.chatManager.findPendingRequest(requestId);
|
||||
if (pendingRequestInfo) {
|
||||
this.chatManager.removePendingRequest(pendingRequestInfo.sessionId, requestId);
|
||||
}
|
||||
request.resolve(response);
|
||||
|
||||
resolver.resolve(response);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@@ -1712,14 +1688,7 @@ export class McpServer extends EventEmitter {
|
||||
}
|
||||
|
||||
// Message storage and synchronization methods - now using ChatManager
|
||||
private storeMessage(sessionId: string, message: ChatMessage): void {
|
||||
this.chatManager.addMessage(sessionId, message);
|
||||
this.debugLogger.log('CHAT', `Stored message in ChatManager for session ${sessionId}: ${message.sender} - ${message.content.substring(0, 50)}...`);
|
||||
}
|
||||
|
||||
private getSessionMessages(sessionId: string): ChatMessage[] {
|
||||
return this.chatManager.getMessages(sessionId);
|
||||
}
|
||||
// Removed: storeMessage and getSessionMessages wrapper methods - call ChatManager directly
|
||||
|
||||
private broadcastMessageToClients(sessionId: string, message: ChatMessage): void {
|
||||
// Broadcast message to all connected SSE clients
|
||||
|
||||
Reference in New Issue
Block a user