@falai/agent 0.8.0 → 0.9.0-alpha-1

package/src/adapters/PrismaAdapter.ts

@@ -10,7 +10,11 @@ import type {
   MessageData,
   SessionStatus,
   PersistenceAdapter,
-} from "../types/persistence";
+  CollectedStateData,
+  MessageRole,
+  Event,
+  CreateSessionData,
+} from "../types";
 
 /**
  * Prisma model operations
@@ -115,8 +119,10 @@ export interface PrismaAdapterOptions {
  * });
  * ```
  */
-export class PrismaAdapter implements PersistenceAdapter {
-  public readonly sessionRepository: SessionRepository;
+export class PrismaAdapter<TData = Record<string, unknown>>
+  implements PersistenceAdapter<TData>
+{
+  public readonly sessionRepository: SessionRepository<TData>;
   public readonly messageRepository: MessageRepository;
   private prisma: PrismaClient;
   private options: Required<Omit<PrismaAdapterOptions, "fieldMappings">> & {
@@ -137,7 +143,7 @@ export class PrismaAdapter implements PersistenceAdapter {
     };
 
     // Initialize repositories
-    this.sessionRepository = new PrismaSessionRepository(
+    this.sessionRepository = new PrismaSessionRepository<TData>(
       this.prisma,
       this.options.tables.sessions!,
       this.options.fieldMappings?.sessions
@@ -191,15 +197,17 @@ export class PrismaAdapter implements PersistenceAdapter {
  * Prisma Session Repository
  * Internal implementation - users should use PrismaAdapter instead
  */
-class PrismaSessionRepository implements SessionRepository {
+class PrismaSessionRepository<TData = Record<string, unknown>>
+  implements SessionRepository<TData>
+{
   private prisma: PrismaClient;
   private tableName: string;
-  private fieldMap: Partial<Record<keyof SessionData, string>>;
+  private fieldMap: Partial<Record<keyof SessionData<TData>, string>>;
 
   constructor(
     prismaClient: PrismaClient,
     tableName: string,
-    fieldMappings?: Partial<Record<keyof SessionData, string>>
+    fieldMappings?: Partial<Record<keyof SessionData<TData>, string>>
   ) {
     this.prisma = prismaClient;
     this.tableName = tableName;
@@ -212,7 +220,7 @@ class PrismaSessionRepository implements SessionRepository {
   private mapFields(data: Record<string, unknown>): Record<string, unknown> {
     const mapped: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(data)) {
-      const mappedKey = this.fieldMap[key as keyof SessionData] || key;
+      const mappedKey = this.fieldMap[key as keyof SessionData<TData>] || key;
       mapped[mappedKey] = value;
     }
     return mapped;
@@ -221,8 +229,8 @@ class PrismaSessionRepository implements SessionRepository {
   /**
    * Map custom schema field names back to our standard field names
    */
-  private unmapFields(data: Record<string, unknown>): SessionData {
-    if (!data) return data as SessionData;
+  private unmapFields(data: Record<string, unknown>): SessionData<TData> {
+    if (!data) throw new Error("Data cannot be null");
 
     const reverseMap: Record<string, string> = {};
     for (const [standardKey, customKey] of Object.entries(this.fieldMap)) {
@@ -235,31 +243,48 @@ class PrismaSessionRepository implements SessionRepository {
       unmapped[unmappedKey] = value;
     }
 
-    return unmapped as unknown as SessionData;
+    // Construct proper SessionData object
+    return {
+      id: unmapped.id as string,
+      userId: unmapped.userId as string | undefined,
+      agentName: unmapped.agentName as string | undefined,
+      status: unmapped.status as "active" | "completed" | "abandoned",
+      currentRoute: unmapped.currentRoute as string | undefined,
+      currentStep: unmapped.currentStep as string | undefined,
+      collectedData: unmapped.collectedData as CollectedStateData<TData>,
+      messageCount: unmapped.messageCount as number | undefined,
+      lastMessageAt: unmapped.lastMessageAt as Date | undefined,
+      completedAt: unmapped.completedAt as Date | undefined,
+      createdAt: unmapped.createdAt as Date,
+      updatedAt: unmapped.updatedAt as Date,
+    };
   }
 
   private getModel(): PrismaModel {
     return this.prisma[this.tableName] as PrismaModel;
   }
 
-  async create(
-    data: Omit<SessionData, "id" | "createdAt" | "updatedAt">
-  ): Promise<SessionData> {
-    const mapped = this.mapFields(data as Record<string, unknown>);
+  async create(data: CreateSessionData<TData>): Promise<SessionData<TData>> {
+    const mapped = this.mapFields({
+      ...data,
+      id:
+        data.id ||
+        `session_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+    });
     const result = await this.getModel().create({
       data: mapped,
     });
     return this.unmapFields(result);
   }
 
-  async findById(id: string): Promise<SessionData | null> {
+  async findById(id: string): Promise<SessionData<TData> | null> {
     const result = await this.getModel().findUnique({
       where: { [this.fieldMap.id || "id"]: id },
     });
     return result ? this.unmapFields(result) : null;
   }
 
-  async findActiveByUserId(userId: string): Promise<SessionData | null> {
+  async findActiveByUserId(userId: string): Promise<SessionData<TData> | null> {
     const result = await this.getModel().findFirst({
       where: {
         [this.fieldMap.userId || "userId"]: userId,
@@ -272,7 +297,10 @@ class PrismaSessionRepository implements SessionRepository {
     return result ? this.unmapFields(result) : null;
   }
 
-  async findByUserId(userId: string, limit = 100): Promise<SessionData[]> {
+  async findByUserId(
+    userId: string,
+    limit = 100
+  ): Promise<SessionData<TData>[]> {
     const results = await this.getModel().findMany({
       where: {
         [this.fieldMap.userId || "userId"]: userId,
@@ -287,8 +315,8 @@ class PrismaSessionRepository implements SessionRepository {
 
   async update(
     id: string,
-    data: Partial<Omit<SessionData, "id" | "createdAt">>
-  ): Promise<SessionData | null> {
+    data: Partial<Omit<SessionData<TData>, "id" | "createdAt">>
+  ): Promise<SessionData<TData> | null> {
     const mapped = this.mapFields(data as Record<string, unknown>);
     const result = await this.getModel().update({
       where: { [this.fieldMap.id || "id"]: id },
@@ -304,7 +332,7 @@ class PrismaSessionRepository implements SessionRepository {
     id: string,
     status: SessionStatus,
     completedAt?: Date
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     const data: Record<string, unknown> = {
       [this.fieldMap.status || "status"]: status,
       [this.fieldMap.updatedAt || "updatedAt"]: new Date(),
@@ -321,8 +349,8 @@ class PrismaSessionRepository implements SessionRepository {
 
   async updateCollectedData(
     id: string,
-    collectedData: Record<string, unknown>
-  ): Promise<SessionData | null> {
+    collectedData: CollectedStateData<TData>
+  ): Promise<SessionData<TData> | null> {
     const result = await this.getModel().update({
       where: { [this.fieldMap.id || "id"]: id },
       data: {
@@ -337,7 +365,7 @@ class PrismaSessionRepository implements SessionRepository {
     id: string,
     route?: string,
     step?: string
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     const data: Record<string, unknown> = {
       [this.fieldMap.updatedAt || "updatedAt"]: new Date(),
     };
@@ -354,7 +382,7 @@ class PrismaSessionRepository implements SessionRepository {
     return this.unmapFields(result);
   }
 
-  async incrementMessageCount(id: string): Promise<SessionData | null> {
+  async incrementMessageCount(id: string): Promise<SessionData<TData> | null> {
     const result = await this.getModel().update({
       where: { [this.fieldMap.id || "id"]: id },
       data: {
@@ -413,7 +441,7 @@ class PrismaMessageRepository implements MessageRepository {
    * Map custom schema field names back to our standard field names
    */
   private unmapFields(data: Record<string, unknown>): MessageData {
-    if (!data) return data as MessageData;
+    if (!data) throw new Error("Data cannot be null");
 
     const reverseMap: Record<string, string> = {};
     for (const [standardKey, customKey] of Object.entries(this.fieldMap)) {
@@ -426,7 +454,21 @@ class PrismaMessageRepository implements MessageRepository {
       unmapped[unmappedKey] = value;
     }
 
-    return unmapped as unknown as MessageData;
+    // Construct proper MessageData object
+    return {
+      id: unmapped.id as string,
+      sessionId: unmapped.sessionId as string,
+      userId: unmapped.userId as string | undefined,
+      role: unmapped.role as MessageRole,
+      content: unmapped.content as string,
+      route: unmapped.route as string | undefined,
+      step: unmapped.step as string | undefined,
+      toolCalls: unmapped.toolCalls as
+        | Array<{ toolName: string; arguments: Record<string, unknown> }>
+        | undefined,
+      event: unmapped.event as Event | undefined,
+      createdAt: unmapped.createdAt as Date,
+    };
   }
 
   private getModel(): PrismaModel {

package/src/adapters/RedisAdapter.ts

@@ -4,13 +4,15 @@
  */
 
 import type {
-  SessionRepository,
+  MessageData,
   MessageRepository,
+  PersistenceAdapter,
   SessionData,
-  MessageData,
+  SessionRepository,
   SessionStatus,
-  PersistenceAdapter,
-} from "../types/persistence";
+  CollectedStateData,
+} from "../types";
+import { createSessionId } from "../utils";
 
 /**
  * Redis client interface - matches ioredis/redis clients
@@ -72,8 +74,10 @@ export interface RedisAdapterOptions {
  * });
  * ```
  */
-export class RedisAdapter implements PersistenceAdapter {
-  public readonly sessionRepository: SessionRepository;
+export class RedisAdapter<TData = Record<string, unknown>>
+  implements PersistenceAdapter<TData>
+{
+  public readonly sessionRepository: SessionRepository<TData>;
   public readonly messageRepository: MessageRepository;
   private redis: RedisClient;
   private keyPrefix: string;
@@ -86,7 +90,7 @@ export class RedisAdapter implements PersistenceAdapter {
     this.sessionTTL = options.sessionTTL || 7 * 24 * 60 * 60; // 7 days
     this.messageTTL = options.messageTTL || 30 * 24 * 60 * 60; // 30 days
 
-    this.sessionRepository = new RedisSessionRepository(
+    this.sessionRepository = new RedisSessionRepository<TData>(
       this.redis,
       this.keyPrefix,
       this.sessionTTL
@@ -107,7 +111,9 @@ export class RedisAdapter implements PersistenceAdapter {
 /**
  * Redis Session Repository
  */
-class RedisSessionRepository implements SessionRepository {
+class RedisSessionRepository<TData = Record<string, unknown>>
+  implements SessionRepository<TData>
+{
   constructor(
     private redis: RedisClient,
     private keyPrefix: string,
@@ -123,11 +129,13 @@ class RedisSessionRepository implements SessionRepository {
   }
 
   async create(
-    data: Omit<SessionData, "id" | "createdAt" | "updatedAt">
-  ): Promise<SessionData> {
-    const id = `session_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    data: Omit<SessionData<TData>, "createdAt" | "updatedAt"> & {
+      id?: string;
+    }
+  ): Promise<SessionData<TData>> {
+    const id = data.id || createSessionId();
     const now = new Date();
-    const session: SessionData = {
+    const session: SessionData<TData> = {
       ...data,
       id,
       createdAt: now,
@@ -150,18 +158,18 @@ class RedisSessionRepository implements SessionRepository {
     return session;
   }
 
-  async findById(id: string): Promise<SessionData | null> {
+  async findById(id: string): Promise<SessionData<TData> | null> {
     const data = await this.redis.get(this.getKey(id));
     if (!data) return null;
     try {
-      return JSON.parse(data) as SessionData;
+      return JSON.parse(data) as SessionData<TData>;
     } catch (error) {
       console.error(`Error parsing session data for id ${id}:`, error);
       return null;
     }
   }
 
-  async findActiveByUserId(userId: string): Promise<SessionData | null> {
+  async findActiveByUserId(userId: string): Promise<SessionData<TData> | null> {
     const sessionIds = await this.redis.hgetall(this.getUserKey(userId));
 
     for (const sessionId of Object.keys(sessionIds)) {
@@ -174,9 +182,12 @@ class RedisSessionRepository implements SessionRepository {
     return null;
   }
 
-  async findByUserId(userId: string, limit = 100): Promise<SessionData[]> {
+  async findByUserId(
+    userId: string,
+    limit = 100
+  ): Promise<SessionData<TData>[]> {
     const sessionIds = await this.redis.hgetall(this.getUserKey(userId));
-    const sessions: SessionData[] = [];
+    const sessions: SessionData<TData>[] = [];
 
     for (const sessionId of Object.keys(sessionIds).slice(0, limit)) {
       const session = await this.findById(sessionId);
@@ -186,18 +197,19 @@ class RedisSessionRepository implements SessionRepository {
     }
 
     return sessions.sort(
-      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
     );
   }
 
   async update(
     id: string,
-    data: Partial<Omit<SessionData, "id" | "createdAt">>
-  ): Promise<SessionData | null> {
+    data: Partial<Omit<SessionData<TData>, "id" | "createdAt">>
+  ): Promise<SessionData<TData> | null> {
     const existing = await this.findById(id);
     if (!existing) return null;
 
-    const updated: SessionData = {
+    const updated: SessionData<TData> = {
       ...existing,
       ...data,
       updatedAt: new Date(),
@@ -212,14 +224,14 @@ class RedisSessionRepository implements SessionRepository {
     id: string,
     status: SessionStatus,
     completedAt?: Date
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     return this.update(id, { status, completedAt });
   }
 
   async updateCollectedData(
     id: string,
-    collectedData: Record<string, unknown>
-  ): Promise<SessionData | null> {
+    collectedData: CollectedStateData<TData>
+  ): Promise<SessionData<TData> | null> {
     return this.update(id, { collectedData });
   }
 
@@ -227,11 +239,11 @@ class RedisSessionRepository implements SessionRepository {
     id: string,
     route?: string,
     step?: string
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     return this.update(id, { currentRoute: route, currentStep: step });
   }
 
-  async incrementMessageCount(id: string): Promise<SessionData | null> {
+  async incrementMessageCount(id: string): Promise<SessionData<TData> | null> {
     const session = await this.findById(id);
     if (!session) return null;
 

package/src/adapters/SQLiteAdapter.ts

@@ -10,7 +10,10 @@ import type {
   MessageData,
   SessionStatus,
   PersistenceAdapter,
-} from "../types/persistence";
+  CollectedStateData,
+  CreateSessionData,
+} from "../types";
+import { createSessionId } from "../utils";
 
 /**
  * SQLite database interface - matches better-sqlite3
@@ -68,8 +71,10 @@ export interface SQLiteAdapterOptions {
  * });
  * ```
  */
-export class SQLiteAdapter implements PersistenceAdapter {
-  public readonly sessionRepository: SessionRepository;
+export class SQLiteAdapter<TData = Record<string, unknown>>
+  implements PersistenceAdapter<TData>
+{
+  public readonly sessionRepository: SessionRepository<TData>;
   public readonly messageRepository: MessageRepository;
   private db: SqliteDatabase;
 
@@ -79,7 +84,10 @@ export class SQLiteAdapter implements PersistenceAdapter {
     const sessionTable = options.tables?.sessions || "agent_sessions";
     const messageTable = options.tables?.messages || "agent_messages";
 
-    this.sessionRepository = new SQLiteSessionRepository(this.db, sessionTable);
+    this.sessionRepository = new SQLiteSessionRepository<TData>(
+      this.db,
+      sessionTable
+    );
     this.messageRepository = new SQLiteMessageRepository(this.db, messageTable);
   }
 
@@ -145,16 +153,16 @@ export class SQLiteAdapter implements PersistenceAdapter {
 /**
  * SQLite Session Repository
  */
-class SQLiteSessionRepository implements SessionRepository {
+class SQLiteSessionRepository<TData = Record<string, unknown>>
+  implements SessionRepository<TData>
+{
   constructor(private db: SqliteDatabase, private tableName: string) {}
 
-  create(
-    data: Omit<SessionData, "id" | "createdAt" | "updatedAt">
-  ): Promise<SessionData> {
-    const id = `session_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+  create(data: CreateSessionData<TData>): Promise<SessionData<TData>> {
+    const id = data.id || createSessionId();
     const now = new Date();
 
-    const session: SessionData = {
+    const session: SessionData<TData> = {
       ...data,
       id,
       status: data.status || "active",
@@ -183,7 +191,7 @@ class SQLiteSessionRepository implements SessionRepository {
     return Promise.resolve(session);
   }
 
-  findById(id: string): Promise<SessionData | null> {
+  findById(id: string): Promise<SessionData<TData> | null> {
     const stmt = this.db.prepare(
       `SELECT * FROM ${this.tableName} WHERE id = ?`
     );
@@ -191,7 +199,7 @@ class SQLiteSessionRepository implements SessionRepository {
     return Promise.resolve(row ? this.deserializeSession(row) : null);
   }
 
-  findActiveByUserId(userId: string): Promise<SessionData | null> {
+  findActiveByUserId(userId: string): Promise<SessionData<TData> | null> {
     const stmt = this.db.prepare(
       `SELECT * FROM ${this.tableName} 
        WHERE user_id = ? AND status = 'active'
@@ -202,7 +210,7 @@ class SQLiteSessionRepository implements SessionRepository {
     return Promise.resolve(row ? this.deserializeSession(row) : null);
   }
 
-  findByUserId(userId: string, limit = 100): Promise<SessionData[]> {
+  findByUserId(userId: string, limit = 100): Promise<SessionData<TData>[]> {
     const stmt = this.db.prepare(
       `SELECT * FROM ${this.tableName} 
        WHERE user_id = ?
@@ -215,8 +223,8 @@ class SQLiteSessionRepository implements SessionRepository {
 
   async update(
     id: string,
-    data: Partial<Omit<SessionData, "id" | "createdAt">>
-  ): Promise<SessionData | null> {
+    data: Partial<Omit<SessionData<TData>, "id" | "createdAt">>
+  ): Promise<SessionData<TData> | null> {
     const fields: string[] = [];
     const values: unknown[] = [];
 
@@ -270,14 +278,14 @@ class SQLiteSessionRepository implements SessionRepository {
     id: string,
     status: SessionStatus,
     completedAt?: Date
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     return await this.update(id, { status, completedAt });
   }
 
   async updateCollectedData(
     id: string,
-    collectedData: Record<string, unknown>
-  ): Promise<SessionData | null> {
+    collectedData: CollectedStateData<TData>
+  ): Promise<SessionData<TData> | null> {
     return await this.update(id, { collectedData });
   }
 
@@ -285,14 +293,14 @@ class SQLiteSessionRepository implements SessionRepository {
     id: string,
     route?: string,
     step?: string
-  ): Promise<SessionData | null> {
+  ): Promise<SessionData<TData> | null> {
     return await this.update(id, {
       currentRoute: route,
       currentStep: step,
     });
   }
 
-  async incrementMessageCount(id: string): Promise<SessionData | null> {
+  async incrementMessageCount(id: string): Promise<SessionData<TData> | null> {
     const stmt = this.db.prepare(
       `UPDATE ${this.tableName}
        SET message_count = message_count + 1,
@@ -314,7 +322,7 @@ class SQLiteSessionRepository implements SessionRepository {
     return Promise.resolve(result.changes > 0);
   }
 
-  private deserializeSession(row: Record<string, unknown>): SessionData {
+  private deserializeSession(row: Record<string, unknown>): SessionData<TData> {
     return {
       id: row.id as string,
       userId: (row.user_id as string) || undefined,
@@ -323,7 +331,9 @@ class SQLiteSessionRepository implements SessionRepository {
       currentRoute: (row.current_route as string) || undefined,
       currentStep: (row.current_step as string) || undefined,
       collectedData: row.collected_data
-        ? (JSON.parse(row.collected_data as string) as Record<string, unknown>)
+        ? (JSON.parse(
+            row.collected_data as string
+          ) as CollectedStateData<TData>)
         : undefined,
       messageCount: (row.message_count as number) || 0,
       lastMessageAt: row.last_message_at