added state and context

Author: nusk0

packages/adapter-sqlite/src/index.ts

@@ -106,6 +106,28 @@ export class SqliteDatabaseAdapter
             }))
             .sort((a, b) => Number(a.createdAt) - Number(b.createdAt));
     }
+
+    async getFormattedConversation(conversationId: UUID): Promise<string> {
+        const conversation = await this.getConversation(conversationId);
+        if (!conversation) return "";
+
+        const messages = await this.getConversationMessages(conversationId);
+        
+        // Format each message with timestamp
+        const formattedMessages = messages.map(msg => {
+            const timestamp = new Date(msg.createdAt).toLocaleString("en-US", {
+                hour: "2-digit",
+                minute: "2-digit",
+                month: "short",
+                day: "numeric"
+            });
+            const username = msg.content.username || msg.userId;
+            return `@${username} (${timestamp}):\n${msg.content.text}`;
+        });
+
+        return `Context: ${conversation.context}\n\n${formattedMessages.join('\n\n')}`;
+    }
+
     async setParticipantUserState(
         roomId: UUID,
         userId: UUID,

packages/client-twitter/src/utils.ts

@@ -1,10 +1,9 @@
 import { Tweet } from "agent-twitter-client";
-import { getEmbeddingZeroVector } from "@elizaos/core";
+import { getEmbeddingZeroVector, composeContext, elizaLogger } from "@elizaos/core";
 import type { Content, Memory, UUID, IAgentRuntime } from "@elizaos/core";
 
 import { stringToUuid } from "@elizaos/core";
 import { ClientBase } from "./base";
-import { elizaLogger } from "@elizaos/core";
 import { DEFAULT_MAX_TWEET_LENGTH } from "./environment";
 import { Media } from "@elizaos/core";
 import fs from "fs";
@@ -440,46 +439,50 @@ export async function analyzeConversation(
     runtime: IAgentRuntime
 ): Promise<void> {
     const conversation = await runtime.databaseAdapter.getConversation(conversationId);
-    console.log("analyzeConversation", conversation)
-    // Get all messages in order
-    const messages = await Promise.all(
-        JSON.parse(conversation.messageIds).map(id =>
-            runtime.messageManager.getMemoryById(id)
-        )
-    );
-
-    // Group messages by user
-    const userMessages = new Map<string, string[]>();
-    for (const message of messages) {
-        if (message.userId === runtime.agentId) continue; // Skip agent's messages
-
-        const username = message.content.username || message.userId;
-        if (!userMessages.has(username)) {
-            userMessages.set(username, []);
-        }
-        userMessages.get(username)?.push(message.content.text);
+    if (!conversation) {
+        elizaLogger.error("No conversation found for analysis", conversationId);
+        return;
     }
 
-    // Format conversation for per-user analysis
-    const prompt = `Analyze each user's messages in this conversation and provide a sentiment score from -1.0 (very negative) to 1.0 (very positive).
-Consider factors like: politeness, engagement, friendliness, and cooperation.
+    // Get all messages in order
+    const messages = await runtime.databaseAdapter.getConversationMessages(conversationId);
+    if (messages.length === 0) {
+        elizaLogger.error("No messages found in conversation for analysis", conversationId);
+        return;
+    }
 
-Context: ${conversation.context}
+    // Get the last message to use for state building
+    const lastMessage = messages[messages.length - 1];
 
-${Array.from(userMessages.entries()).map(([username, msgs]) =>
-    `Messages from @${username}:\n${msgs.join('\n')}`
-).join('\n\n')}
+    // Build state with conversation context
+    const state = await runtime.composeState(lastMessage, {
+        conversationId: conversationId,
+        twitterUserName: runtime.getSetting("TWITTER_USERNAME")
+    });
 
-Return ONLY a JSON object with usernames as keys and scores as values. Example format:
-{
-    "@user1": 0.8,
-    "@user2": -0.3
-}`;
+    // Format conversation for per-user analysis
+    const analysisTemplate = ` 
+    #Recent Conversations:
+    {{recentUserConversations}}
+
+    #Instructions:
+    Evaluate the messages the other users sent to you in this conversation. 
+    Rate each users messages sent to you as a whole using these metrics: [-5] very bad, [0] neutral, [5] very good. 
+    Evaluates these messages as the character ${runtime.character.name} with the context of the whole conversation. 
+    If you aren't sure if the message was directed to you, or you're missing context to give a good answer, give the score [0] neutral. 
+
+    Return ONLY a JSON object with usernames as keys and scores as values. Example format:
+    {
+        "@user1": 0.8,
+        "@user2": -0.3
+    }`;
+    const context = composeContext({
+        state,
+        template: analysisTemplate
+    });
 
     const analysis = await runtime.generateText({
-        prompt,
-        temperature: 0.7,
-        maxTokens: 500
+        prompt: context,
     });
 
     elizaLogger.log("User sentiment scores:", analysis);
@@ -495,13 +498,17 @@ Return ONLY a JSON object with usernames as keys and scores as values. Example f
 
         // Update user rapport based on sentiment scores
         for (const [username, score] of Object.entries(sentimentScores)) {
-            const userId = messages.find(m => m.content.username === username.replace('@', ''))?.userId;
+            const userId = messages.find(m => 
+                (m.content.username || m.userId) === username.replace('@', '')
+            )?.userId;
+            
             if (userId) {
-                await runtime.databaseAdapter.updateUserRapport({
+                await runtime.databaseAdapter.setUserRapport(
                     userId,
-                    agentId: runtime.agentId,
-                    sentimentScore: score as number
-                });
+                    runtime.agentId,
+                    score as number
+                );
+                elizaLogger.log(`Updated rapport for user ${username}:`, score);
             }
         }
     } catch (error) {

packages/core/src/database.ts

@@ -8,6 +8,7 @@ import {
     type UUID,
     Participant,
     IDatabaseAdapter,
+    Conversation,
 } from "./types.ts";
 import { CircuitBreaker } from "./database/CircuitBreaker";
 import { elizaLogger } from "./logger";
@@ -327,13 +328,6 @@ export abstract class DatabaseAdapter<DB = any> implements IDatabaseAdapter {
      */
     abstract getParticipantsForAccount(userId: UUID): Promise<Participant[]>;
 
-    /**
-     * Retrieves participants associated with a specific account.
-     * @param userId The UUID of the account.
-     * @returns A Promise that resolves to an array of Participant objects.
-     */
-    abstract getParticipantsForAccount(userId: UUID): Promise<Participant[]>;
-
     /**
      * Retrieves participants for a specific room.
      * @param roomId The UUID of the room for which to retrieve participants.
@@ -402,4 +396,36 @@ export abstract class DatabaseAdapter<DB = any> implements IDatabaseAdapter {
             throw error;
         }
     }
+
+    async getFormattedConversation(conversationId: UUID): Promise<string> {
+        throw new Error("Method not implemented.");
+    }
+
+    async getConversation(conversationId: UUID): Promise<Conversation | null> {
+        throw new Error("Method not implemented.");
+    }
+
+    async storeConversation(conversation: Conversation): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async updateConversation(conversation: Partial<Conversation> & { id: UUID }): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async getConversationsByStatus(status: string, limit?: number): Promise<Conversation[]> {
+        throw new Error("Method not implemented.");
+    }
+
+    async getConversationMessages(conversationId: UUID): Promise<Memory[]> {
+        throw new Error("Method not implemented.");
+    }
+
+    async setUserRapport(userId: UUID, agentId: UUID, score: number): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async getUserRapport(userId: UUID, agentId: UUID): Promise<number> {
+        throw new Error("Method not implemented.");
+    }
 }

packages/core/src/runtime.ts

@@ -934,12 +934,19 @@ Text: ${attachment.text}
             const recentInteractionsData = existingMemories.slice(0, 20);
             return recentInteractionsData;
         };
-
+        
         const recentInteractions =
             userId !== this.agentId
                 ? await getRecentInteractions(userId, this.agentId)
                 : [];
 
+        // Get formatted conversation if conversationId is provided
+        let recentUserConversations = "";
+        if (additionalKeys.conversationId) {
+            const currentConversationId = additionalKeys.conversationId as UUID;
+            recentUserConversations = await this.databaseAdapter.getFormattedConversation(currentConversationId);
+        }
+
         const getRecentMessageInteractions = async (
             recentInteractionsData: Memory[]
         ): Promise<string> => {

packages/core/src/types.ts

@@ -328,7 +328,7 @@ export interface State {
     userRapport?: number;
 
     /** Recent conversations specific to the current user */
-    recentUserConversations?: Memory[];
+    recentUserConversations?: string;
 
     /** Additional dynamic properties */
     [key: string]: unknown;
@@ -946,6 +946,22 @@ export interface IDatabaseAdapter {
     }): Promise<Relationship | null>;
 
     getRelationships(params: { userId: UUID }): Promise<Relationship[]>;
+
+    getFormattedConversation(conversationId: UUID): Promise<string>;
+
+    getConversation(conversationId: UUID): Promise<Conversation | null>;
+
+    storeConversation(conversation: Conversation): Promise<void>;
+
+    updateConversation(conversation: Partial<Conversation> & { id: UUID }): Promise<void>;
+
+    getConversationsByStatus(status: string, limit?: number): Promise<Conversation[]>;
+
+    getConversationMessages(conversationId: UUID): Promise<Memory[]>;
+
+    setUserRapport(userId: UUID, agentId: UUID, score: number): Promise<void>;
+
+    getUserRapport(userId: UUID, agentId: UUID): Promise<number>;
 }
 
 export interface IDatabaseCacheAdapter {
@@ -1257,3 +1273,25 @@ export interface ActionResponse {
 export interface ISlackService extends Service {
     client: any;
 }
+
+export interface Conversation {
+    id: UUID;
+    messageIds: string; // JSON string array
+    participantIds: string; // JSON string array
+    startedAt: Date;
+    lastMessageAt: Date;
+    closedAt?: Date;
+    context: string;
+    status: 'ACTIVE' | 'CLOSED';
+    agentId: UUID;
+    rootTweetId?: string;
+}
+// Encode function
+export function encodeString(str: string): string {
+    return Buffer.from(str).toString('base64');
+}
+
+// Decode function
+export function decodeString(encoded: string): string {
+    return Buffer.from(encoded, 'base64').toString();
+}