ag/unisono
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

'Afraid to Ask' implemented

Browse Source
This commit is contained in:
aodulov
2025-10-13 13:14:30 +03:00
parent 09269190c1
commit 5f8541a5f3
20 changed files with 2081 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

262
backend/src/ws/index.ts
View File

@@ -1,7 +1,11 @@
import { WebSocketServer, WebSocket } from 'ws';
import { LLMService } from '../services/LLMService';
import { EncryptionService } from '../services/EncryptionService';
import { v4 as uuidv4 } from 'uuid';
// Initialize Encryption Service
const encryptionService = new EncryptionService(process.env.ENCRYPTION_KEY || '');
// Types from the frontend
interface Decision {
goTo: string;
@@ -20,13 +24,20 @@ export enum SessionState {
ERROR = 'ERROR',
}
interface EncryptedResponseData {
wants: string[];
accepts: string[];
noGoes: string[];
afraidToAsk: string; // Encrypted afraidToAsk idea
}
// A map to hold session data, including clients and the latest state
interface SessionData {
state: SessionState; // Current phase of the session
topic: string | null; // The topic of the session
expectedResponses: number; // The number set by the first user in State A.
submittedCount: number; // The current count of submitted responses.
responses: Map<string, any>; // Stores the submitted desire objects. Map<ClientID, ResponseData>
responses: Map<string, EncryptedResponseData>; // Stores the submitted desire objects. Map<ClientID, EncryptedResponseData>
clients: Map<string, WebSocket>; // Maps the persistent Client ID to their active WebSocket connection object.
finalResult: any | null; // The result returned by the LLM.
}
@@ -35,11 +46,39 @@ export const sessions = new Map<string, SessionData>();
// Initialize LLM Service (API key from environment)
const llmService = new LLMService(process.env.GEMINI_API_KEY || '');
// Structured logging function
const logEvent = (eventName: string, sessionId: string, details: object = {}) => {
console.log(JSON.stringify({ timestamp: new Date().toISOString(), eventName, sessionId, ...details }));
};
// Metrics recording function
const recordMetric = (metricName: string, value: number | string, sessionId: string, details: object = {}) => {
console.log(JSON.stringify({ timestamp: new Date().toISOString(), metricName, value, sessionId, ...details }));
};
// Helper to create a serializable version of the session state
const getSerializableSession = (sessionData: SessionData) => {
const getSerializableSession = (sessionData: SessionData, currentClientId: string | null = null) => {
const filteredResponses = new Map<string, any>();
sessionData.responses.forEach((response, clientId) => {
if (clientId === currentClientId) {
// For the current client, decrypt and send their own full response
const decryptedWants = response.wants.map((d: string) => encryptionService.decrypt(d));
const decryptedAccepts = response.accepts.map((d: string) => encryptionService.decrypt(d));
const decryptedNoGoes = response.noGoes.map((d: string) => encryptionService.decrypt(d));
const decryptedAfraidToAsk = encryptionService.decrypt(response.afraidToAsk);
filteredResponses.set(clientId, { wants: decryptedWants, accepts: decryptedAccepts, noGoes: decryptedNoGoes, afraidToAsk: decryptedAfraidToAsk });
} else {
// For other clients, only send non-AfraidToAsk parts (wants, accepts, noGoes without AfraidToAsk)
const decryptedWants = response.wants.map((d: string) => encryptionService.decrypt(d));
const decryptedAccepts = response.accepts.map((d: string) => encryptionService.decrypt(d));
const decryptedNoGoes = response.noGoes.map((d: string) => encryptionService.decrypt(d));
filteredResponses.set(clientId, { wants: decryptedWants, accepts: decryptedAccepts, noGoes: decryptedNoGoes, afraidToAsk: "" }); // Hide afraidToAsk for other clients
}
});
return {
...sessionData,
responses: Object.fromEntries(sessionData.responses),
responses: Object.fromEntries(filteredResponses),
clients: Array.from(sessionData.clients.keys()), // Only send client IDs, not the WebSocket objects
};
};
@@ -47,15 +86,15 @@ const getSerializableSession = (sessionData: SessionData) => {
export const broadcastToSession = (sessionId: string, message: any, excludeClientId: string | null = null) => {
const sessionData = sessions.get(sessionId);
if (sessionData) {
const serializableMessage = {
...message,
payload: {
...message.payload,
session: getSerializableSession(sessionData),
},
};
sessionData.clients.forEach((client, clientId) => {
if (clientId !== excludeClientId && client.readyState === WebSocket.OPEN) {
const serializableMessage = {
...message,
payload: {
...message.payload,
session: getSerializableSession(sessionData, clientId), // Pass clientId to getSerializableSession
},
};
client.send(JSON.stringify(serializableMessage));
}
});
@@ -106,87 +145,7 @@ export const createWebSocketServer = (server: any) => {
}
console.log(`Received message from ${clientId} in session ${sessionId}:`, type);
switch (type) {
case 'REGISTER_CLIENT':
break;
case 'SETUP_SESSION':
if (sessionData.state === SessionState.SETUP) {
const { expectedResponses, topic } = payload;
if (typeof expectedResponses !== 'number' || expectedResponses <= 0) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'Invalid expectedResponses' } }));
return;
}
sessionData.expectedResponses = expectedResponses;
sessionData.topic = topic || 'Untitled Session';
sessionData.state = SessionState.GATHERING;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
console.log(`Session ${sessionId} moved to GATHERING with topic "${sessionData.topic}" and ${expectedResponses} expected responses.`);
} else {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Session is not in SETUP state. Current state: ${sessionData.state}` } }));
}
break;
case 'SUBMIT_RESPONSE':
if (sessionData.state === SessionState.GATHERING) {
if (sessionData.responses.has(clientId)) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'You have already submitted a response for this session.' } }));
return;
}
const { wants, accepts, noGoes } = payload.response;
if ([...wants, ...accepts, ...noGoes].some(desire => desire.length > 500)) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'One of your desires exceeds the 500 character limit.' } }));
return;
}
const hasContradictionsGist = await llmService.checkForInnerContradictions(payload.response);
if (hasContradictionsGist) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Your submission contains inner contradictions: ${hasContradictionsGist} Please resolve them and submit again.` } }));
return;
}
sessionData.responses.set(clientId, payload.response);
sessionData.submittedCount++;
console.log(`Client ${clientId} submitted response. Submitted count: ${sessionData.submittedCount}/${sessionData.expectedResponses}`);
if (sessionData.submittedCount === sessionData.expectedResponses) {
sessionData.state = SessionState.HARMONIZING;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
console.log(`Session ${sessionId} moved to HARMONIZING. Triggering LLM analysis.`);
// Perform LLM analysis asynchronously
(async () => {
try {
const allDesires = Array.from(sessionData.responses.values());
const decision = await llmService.analyzeDesires(allDesires);
sessionData.finalResult = decision;
sessionData.state = SessionState.FINAL;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
console.log(`Analysis complete for session ${sessionId}. Result:`, decision);
} catch (error: any) {
console.error(`Error during analysis for session ${sessionId}:`, error.message);
sessionData.state = SessionState.ERROR;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
}
})();
} else {
// Only broadcast the latest count if the session is not yet harmonizing
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
}
} else {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Session is not in GATHERING state. Current state: ${sessionData.state}` } }));
}
break;
default:
console.warn(`Unknown message type: ${type} from client ${clientId} in session ${sessionId}`);
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Unknown message type: ${type}` } }));
break;
}
await handleWebSocketMessage(ws, sessionId, parsedMessage);
});
ws.on('close', () => {
@@ -207,6 +166,7 @@ export const createWebSocketServer = (server: any) => {
if (sessionData.clients.size === 0) {
sessions.delete(sessionId);
logEvent('session_purged', sessionId);
console.log(`Session ${sessionId} closed and state cleared.`);
}
});
@@ -218,3 +178,123 @@ export const createWebSocketServer = (server: any) => {
return wss;
};
export const handleWebSocketMessage = async (ws: WebSocket, sessionId: string, parsedMessage: any) => {
const { type, clientId, payload } = parsedMessage;
if (!clientId) {
console.error(`Received message without clientId in session ${sessionId}. Type: ${type}`);
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'clientId is required' } }));
return;
}
const sessionData = sessions.get(sessionId)!;
if (!sessionData.clients.has(clientId)) {
sessionData.clients.set(clientId, ws);
console.log(`Client ${clientId} registered for session: ${sessionId}. Total clients: ${sessionData.clients.size}`);
ws.send(JSON.stringify({ type: 'STATE_UPDATE', payload: { session: getSerializableSession(sessionData, clientId) } }));
}
console.log(`Received message from ${clientId} in session ${sessionId}:`, type);
switch (type) {
case 'REGISTER_CLIENT':
break;
case 'SETUP_SESSION':
if (sessionData.state === SessionState.SETUP) {
const { expectedResponses, topic } = payload;
if (typeof expectedResponses !== 'number' || expectedResponses <= 0) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'Invalid expectedResponses' } }));
return;
}
sessionData.expectedResponses = expectedResponses;
sessionData.topic = topic || 'Untitled Session';
sessionData.state = SessionState.GATHERING;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
console.log(`Session ${sessionId} moved to GATHERING with topic "${sessionData.topic}" and ${expectedResponses} expected responses.`);
} else {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Session is not in SETUP state. Current state: ${sessionData.state}` } }));
}
break;
case 'SUBMIT_RESPONSE':
if (sessionData.state === SessionState.GATHERING) {
if (sessionData.responses.has(clientId)) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'You have already submitted a response for this session.' } }));
return;
}
const { wants, accepts, noGoes, afraidToAsk } = payload.response;
if ([...wants, ...accepts, ...noGoes].some(desire => desire.length > 500) || afraidToAsk.length > 500) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: 'One of your desires or afraidToAsk exceeds the 500 character limit.' } }));
return;
}
const hasContradictionsGist = await llmService.checkForInnerContradictions(payload.response);
if (hasContradictionsGist) {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Your submission contains inner contradictions: ${hasContradictionsGist} Please resolve them and submit again.` } }));
return;
}
const encryptedWants = wants.map((d: string) => encryptionService.encrypt(d));
const encryptedAccepts = accepts.map((d: string) => encryptionService.encrypt(d));
const encryptedNoGoes = noGoes.map((d: string) => encryptionService.encrypt(d));
const encryptedAfraidToAsk = encryptionService.encrypt(afraidToAsk);
sessionData.responses.set(clientId, { wants: encryptedWants, accepts: encryptedAccepts, noGoes: encryptedNoGoes, afraidToAsk: encryptedAfraidToAsk });
sessionData.submittedCount++;
logEvent('response_submitted', sessionId, { clientId, submittedCount: sessionData.submittedCount });
console.log(`Client ${clientId} submitted response. Submitted count: ${sessionData.submittedCount}/${sessionData.expectedResponses}`);
if (sessionData.submittedCount === sessionData.expectedResponses) {
sessionData.state = SessionState.HARMONIZING;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
logEvent('session_harmonizing', sessionId, { expectedResponses: sessionData.expectedResponses });
console.log(`Session ${sessionId} moved to HARMONIZING. Triggering LLM analysis.`);
// Perform LLM analysis asynchronously
(async () => {
let durationMs: number = 0; // Declare here
try {
logEvent('llm_analysis_started', sessionId);
const startTime = process.hrtime.bigint(); const allDecryptedDesires = Array.from(sessionData.responses.values()).map(encryptedResponse => {
const decryptedWants = encryptedResponse.wants.map((d: string) => encryptionService.decrypt(d));
const decryptedAccepts = encryptedResponse.accepts.map((d: string) => encryptionService.decrypt(d));
const decryptedNoGoes = encryptedResponse.noGoes.map((d: string) => encryptionService.decrypt(d));
const decryptedAfraidToAsk = encryptionService.decrypt(encryptedResponse.afraidToAsk);
return { wants: decryptedWants, accepts: decryptedAccepts, noGoes: decryptedNoGoes, afraidToAsk: decryptedAfraidToAsk };
});
const decision = await llmService.analyzeDesires(allDecryptedDesires);
sessionData.finalResult = decision;
sessionData.state = SessionState.FINAL;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
logEvent('llm_analysis_completed', sessionId, { result: decision });
recordMetric('llm_analysis_duration', durationMs, sessionId, { status: 'success' }); recordMetric('llm_analysis_availability', 'available', sessionId);
console.log(`Analysis complete for session ${sessionId}. Result:`, decision);
} catch (error: any) {
console.error(`Error during analysis for session ${sessionId}:`, error.message);
sessionData.state = SessionState.ERROR;
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
logEvent('llm_analysis_error', sessionId, { error: error.message });
recordMetric('llm_analysis_availability', 'unavailable', sessionId, { error: error.message });
}
})();
} else {
// Only broadcast the latest count if the session is not yet harmonizing
broadcastToSession(sessionId, { type: 'STATE_UPDATE', payload: {} });
}
} else {
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Session is not in GATHERING state. Current state: ${sessionData.state}` } }));
}
break;
default:
console.warn(`Unknown message type: ${type} from client ${clientId} in session ${sessionId}`);
ws.send(JSON.stringify({ type: 'ERROR', payload: { message: `Unknown message type: ${type}` } }));
break;
}
};