Skip to content

Commit 2f34021

Browse files
lalalunelalalune
committed
Merge branch 'shaw/v2-chat-not-woroking' of https://github.com/elizaOS/eliza into shaw/v2-prettier
2 parents 4b0ec2d + ba29d77 commit 2f34021

14 files changed

+1049
-232
lines changed

‎packages/cli/src/server/api/room-mappings.ts

+244-97
Large diffs are not rendered by default.

‎packages/cli/src/server/services/RoomMappingService.ts

+166-7
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import { v4 as uuidv4 } from 'uuid';
2-
import type { UUID, ChannelType } from '@elizaos/core';
3-
import { logger } from '@elizaos/core';
2+
import type { UUID, ChannelType, IAgentRuntime } from '@elizaos/core';
3+
import { logger, createUniqueUuid } from '@elizaos/core';
44

55
/**
66
* Interface representing a room mapping entry
@@ -17,33 +17,55 @@ export interface RoomMappingEntry {
1717
* and agent-specific rooms (as they exist in each agent's context)
1818
*/
1919
export class RoomMappingService {
20+
private static instance: RoomMappingService | null = null;
2021
// In-memory storage of room mappings
2122
private roomMappings: RoomMappingEntry[] = [];
2223
// Conceptual room registry
23-
private conceptualRooms: Map<UUID, { name: string; type: ChannelType; createdAt: number }> =
24-
new Map();
24+
private conceptualRooms: Map<
25+
UUID,
26+
{
27+
name: string;
28+
type: ChannelType;
29+
createdAt: number;
30+
ownerAgentId: UUID; // The user agent that created/owns this room
31+
}
32+
> = new Map();
2533

26-
constructor() {
34+
private constructor() {
2735
logger.info('[RoomMappingService] Initializing room mapping service');
2836
}
2937

38+
/**
39+
* Get the singleton instance of RoomMappingService
40+
*/
41+
public static getInstance(): RoomMappingService {
42+
if (!RoomMappingService.instance) {
43+
RoomMappingService.instance = new RoomMappingService();
44+
}
45+
return RoomMappingService.instance;
46+
}
47+
3048
/**
3149
* Creates a new conceptual room
3250
* @param name The name of the room
3351
* @param type The type of room (DM, GROUP, etc)
52+
* @param ownerAgentId The user agent ID that owns this room
3453
* @returns The ID of the newly created conceptual room
3554
*/
36-
async createConceptualRoom(name: string, type: ChannelType): Promise<UUID> {
55+
async createConceptualRoom(name: string, type: ChannelType, ownerAgentId: UUID): Promise<UUID> {
3756
const roomId = uuidv4() as UUID;
3857

3958
// Register the conceptual room
4059
this.conceptualRooms.set(roomId, {
4160
name,
4261
type,
4362
createdAt: Date.now(),
63+
ownerAgentId,
4464
});
4565

46-
logger.info(`[RoomMappingService] Created conceptual room ${roomId} (${name}, ${type})`);
66+
logger.info(
67+
`[RoomMappingService] Created conceptual room ${roomId} (${name}, ${type}, owned by ${ownerAgentId})`
68+
);
4769

4870
return roomId;
4971
}
@@ -133,4 +155,141 @@ export class RoomMappingService {
133155
const mappings = await this.getAllMappingsForRoom(conceptualRoomId);
134156
return mappings.map((mapping) => mapping.agentId);
135157
}
158+
159+
/**
160+
* Creates a new mirrored room in an agent's context for a conceptual room
161+
* @param conceptualRoomId The ID of the conceptual room
162+
* @param targetAgentId The ID of the agent to create a room for
163+
* @param agentRuntime The runtime for the agent
164+
* @returns The ID of the newly created agent-specific room
165+
*/
166+
async createMirroredRoom(
167+
conceptualRoomId: UUID,
168+
targetAgentId: UUID,
169+
agentRuntime: IAgentRuntime
170+
): Promise<UUID> {
171+
// Get the conceptual room details
172+
const conceptualRoom = await this.getConceptualRoom(conceptualRoomId);
173+
if (!conceptualRoom) {
174+
throw new Error(`Conceptual room ${conceptualRoomId} not found`);
175+
}
176+
177+
// Create a unique room ID for this agent
178+
const agentRoomId = createUniqueUuid(agentRuntime, `room-${conceptualRoomId}`) as UUID;
179+
180+
// Ensure the room exists in the agent's context
181+
await agentRuntime.ensureRoomExists({
182+
id: agentRoomId,
183+
name: conceptualRoom.name,
184+
type: conceptualRoom.type,
185+
source: 'mirrored',
186+
worldId: null,
187+
metadata: {
188+
conceptualRoomId, // Store the conceptual room ID for reference
189+
ownerAgentId: conceptualRoom.ownerAgentId,
190+
},
191+
});
192+
193+
// Store the mapping
194+
await this.storeRoomMapping(conceptualRoomId, targetAgentId, agentRoomId);
195+
196+
logger.info(
197+
`[RoomMappingService] Created mirrored room ${agentRoomId} for agent ${targetAgentId} (conceptual room: ${conceptualRoomId})`
198+
);
199+
200+
return agentRoomId;
201+
}
202+
203+
/**
204+
* Gets the conceptual room ID for an agent-specific room
205+
* @param agentRoomId The ID of the agent-specific room
206+
* @param agentId The ID of the agent
207+
* @returns The conceptual room ID or undefined if not found
208+
*/
209+
async getConceptualRoomId(agentRoomId: UUID, agentId: UUID): Promise<UUID | undefined> {
210+
const mapping = this.roomMappings.find(
211+
(mapping) => mapping.agentRoomId === agentRoomId && mapping.agentId === agentId
212+
);
213+
return mapping?.conceptualRoomId;
214+
}
215+
216+
/**
217+
* Gets all mirrored rooms for a conceptual room
218+
* @param conceptualRoomId The ID of the conceptual room
219+
* @returns Map of agent IDs to their room IDs for this conceptual room
220+
*/
221+
async getMirroredRooms(conceptualRoomId: UUID): Promise<Map<UUID, UUID>> {
222+
const mappings = await this.getAllMappingsForRoom(conceptualRoomId);
223+
const mirroredRooms = new Map<UUID, UUID>();
224+
225+
for (const mapping of mappings) {
226+
mirroredRooms.set(mapping.agentId, mapping.agentRoomId);
227+
}
228+
229+
return mirroredRooms;
230+
}
231+
232+
/**
233+
* Add a participant to all mirrored rooms for a conceptual room
234+
* @param conceptualRoomId The ID of the conceptual room
235+
* @param participantId The ID of the participant to add
236+
* @param agentRuntimes Map of agent IDs to their runtimes
237+
*/
238+
async addParticipantToMirroredRooms(
239+
conceptualRoomId: UUID,
240+
participantId: UUID,
241+
agentRuntimes: Map<UUID, IAgentRuntime>
242+
): Promise<void> {
243+
const mirroredRooms = await this.getMirroredRooms(conceptualRoomId);
244+
245+
for (const [agentId, agentRoomId] of mirroredRooms.entries()) {
246+
const runtime = agentRuntimes.get(agentId);
247+
if (runtime) {
248+
// Ensure the participant entity exists in this agent's context
249+
try {
250+
await runtime.getEntityById(participantId);
251+
} catch (error) {
252+
// Create a basic entity if it doesn't exist
253+
await runtime.createEntity({
254+
id: participantId,
255+
names: ['User'],
256+
agentId: runtime.agentId,
257+
});
258+
}
259+
260+
// Add the participant to the room
261+
await runtime.addParticipant(participantId, agentRoomId);
262+
await runtime.setParticipantUserState(agentRoomId, participantId, 'FOLLOWED');
263+
264+
logger.info(
265+
`[RoomMappingService] Added participant ${participantId} to mirrored room ${agentRoomId} for agent ${agentId}`
266+
);
267+
}
268+
}
269+
}
270+
271+
/**
272+
* Remove a participant from all mirrored rooms for a conceptual room
273+
* @param conceptualRoomId The ID of the conceptual room
274+
* @param participantId The ID of the participant to remove
275+
* @param agentRuntimes Map of agent IDs to their runtimes
276+
*/
277+
async removeParticipantFromMirroredRooms(
278+
conceptualRoomId: UUID,
279+
participantId: UUID,
280+
agentRuntimes: Map<UUID, IAgentRuntime>
281+
): Promise<void> {
282+
const mirroredRooms = await this.getMirroredRooms(conceptualRoomId);
283+
284+
for (const [agentId, agentRoomId] of mirroredRooms.entries()) {
285+
const runtime = agentRuntimes.get(agentId);
286+
if (runtime) {
287+
await runtime.removeParticipant(participantId, agentRoomId);
288+
289+
logger.info(
290+
`[RoomMappingService] Removed participant ${participantId} from mirrored room ${agentRoomId} for agent ${agentId}`
291+
);
292+
}
293+
}
294+
}
136295
}

‎packages/cli/src/server/services/UserAgentService.ts

+107
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
import { v4 as uuidv4 } from 'uuid';
2+
import type { UUID } from '@elizaos/core';
3+
import { logger } from '@elizaos/core';
4+
import type { Database } from '../database/Database';
5+
import type { Agent } from '@elizaos/core';
6+
7+
/**
8+
* Service to manage user agents in the system.
9+
* User agents represent human users in the agent system but don't have AI capabilities.
10+
*/
11+
export class UserAgentService {
12+
private static instance: UserAgentService | null = null;
13+
14+
// Map of user IDs to their agent IDs
15+
private userAgentMap: Map<string, UUID> = new Map();
16+
17+
private constructor(private db: Database) {
18+
logger.info('[UserAgentService] Initializing user agent service');
19+
}
20+
21+
/**
22+
* Get the singleton instance of UserAgentService
23+
*/
24+
public static getInstance(db: Database): UserAgentService {
25+
if (!UserAgentService.instance) {
26+
UserAgentService.instance = new UserAgentService(db);
27+
}
28+
return UserAgentService.instance;
29+
}
30+
31+
/**
32+
* Get or create a user agent for a user ID
33+
* @param userId The user's unique identifier
34+
* @param username The user's display name
35+
* @returns The UUID of the user's agent
36+
*/
37+
public async getOrCreateUserAgent(userId: string, username: string): Promise<UUID> {
38+
// Check if we already have an agent for this user
39+
if (this.userAgentMap.has(userId)) {
40+
return this.userAgentMap.get(userId)!;
41+
}
42+
43+
// Check if agent exists in database
44+
const agents = await this.db.getAgents();
45+
const existingAgent = agents.find(
46+
(a) => a.metadata?.isUserAgent && a.metadata.userId === userId
47+
);
48+
49+
if (existingAgent) {
50+
this.userAgentMap.set(userId, existingAgent.id);
51+
return existingAgent.id;
52+
}
53+
54+
// Create a new user agent
55+
const agentId = uuidv4() as UUID;
56+
57+
const userAgent: Agent = {
58+
id: agentId,
59+
name: `User: ${username}`,
60+
description: `User agent for ${username}`,
61+
modelType: 'none', // No AI model for user agents
62+
settings: {},
63+
metadata: {
64+
isUserAgent: true,
65+
userId: userId,
66+
username: username,
67+
isEnabled: false, // User agents aren't enabled for AI responses
68+
},
69+
};
70+
71+
// Save to database
72+
await this.db.ensureAgentExists(userAgent);
73+
logger.info(`[UserAgentService] Created new user agent ${agentId} for user ${userId}`);
74+
75+
// Cache the mapping
76+
this.userAgentMap.set(userId, agentId);
77+
78+
return agentId;
79+
}
80+
81+
/**
82+
* Get the agent ID for a user
83+
* @param userId The user's unique identifier
84+
* @returns The UUID of the user's agent, or undefined if not found
85+
*/
86+
public getUserAgentId(userId: string): UUID | undefined {
87+
return this.userAgentMap.get(userId);
88+
}
89+
90+
/**
91+
* Check if an agent is a user agent
92+
* @param agentId The agent ID to check
93+
* @returns True if the agent is a user agent, false otherwise
94+
*/
95+
public async isUserAgent(agentId: UUID): Promise<boolean> {
96+
const agent = await this.db.getAgent(agentId);
97+
return !!agent?.metadata?.isUserAgent;
98+
}
99+
100+
/**
101+
* Get all user agent IDs
102+
* @returns Array of user agent IDs
103+
*/
104+
public getUserAgentIds(): UUID[] {
105+
return Array.from(this.userAgentMap.values());
106+
}
107+
}

0 commit comments

Comments
 (0)