@ainetwork/adk-provider-memory-inmemory 0.1.1 → 0.1.2

package/implements/intent.memory.ts

@@ -0,0 +1,34 @@
+import { randomUUID } from "node:crypto";
+import type { Intent } from "@ainetwork/adk/types/memory";
+import { IIntentMemory } from "@ainetwork/adk/modules";
+
+export class InMemoryIntent implements IIntentMemory {
+	public intents: Map<string, Intent> = new Map();
+
+  public async connect(): Promise<void> {}
+  public async disconnect(): Promise<void> {}
+  public isConnected(): boolean {
+    return true;
+  }
+
+  public async getIntent(intentId: string): Promise<Intent | undefined> {
+    return this.intents.get(intentId);
+  };
+
+	public async saveIntent(intent: Intent): Promise<void> {
+    const newId = randomUUID();
+    this.intents.set(newId, intent);
+  };
+
+	public async updateIntent(intentId: string, intent: Intent): Promise<void> {
+    this.intents.set(intentId, intent);
+  };
+
+	public async deleteIntent(intentId: string): Promise<void> {
+    this.intents.delete(intentId);
+  };
+
+	public async listIntents(): Promise<Intent[]> {
+    return Array.from(this.intents.values());
+  };
+}

package/implements/session.memory.ts

@@ -0,0 +1,79 @@
+import { randomUUID } from "node:crypto";
+import type { ChatObject, SessionObject, SessionMetadata } from "@ainetwork/adk/types/memory";
+import { ISessionMemory } from "@ainetwork/adk/modules";
+
+type InMemorySessionObject = {
+  chats: Map<string, ChatObject>
+}
+
+type InMemorySessionMetadata = {
+  sessionId: string;
+  title?: string;
+  updatedAt: number;
+  createdAt: number;
+}
+
+export class InMemorySession implements ISessionMemory {
+	public sessions: Map<string, InMemorySessionObject> = new Map();
+  public userSessionIndex: Map<string, Set<InMemorySessionMetadata>> = new Map();
+
+  public async connect(): Promise<void> {}
+  public async disconnect(): Promise<void> {}
+  public isConnected(): boolean {
+    return true;
+  }
+
+  private generateKey(userId: string, sessionId: string) {
+    return `${userId}:${sessionId}`;
+  }
+
+  public async getSession(userId: string, sessionId: string): Promise<SessionObject | undefined> {
+    const key = this.generateKey(userId, sessionId);
+    const res = this.sessions.get(key);
+    if (res) {
+      const sessionObject: SessionObject = {
+        chats: Object.fromEntries(res.chats)
+      };
+      return sessionObject;
+    }
+    return undefined;
+  };
+
+	public async createSession(userId: string, sessionId: string): Promise<void> {
+    const key = this.generateKey(userId, sessionId);
+    if (!this.userSessionIndex.has(userId)) {
+      this.userSessionIndex.set(userId, new Set());
+    }
+    if (!this.sessions.has(key)) {
+      this.sessions.set(key, { chats: new Map() });
+      const metadata: InMemorySessionMetadata = {
+        sessionId, createdAt: Date.now(), updatedAt: Date.now(),
+      }
+      this.userSessionIndex.get(userId)?.add(metadata);
+    }
+  };
+
+	public async addChatToSession(userId: string, sessionId: string, chat: ChatObject): Promise<void> {
+    const key = this.generateKey(userId, sessionId);
+    const newChatId = randomUUID();
+    if (!this.sessions.has(key)) {
+      await this.createSession(userId, sessionId);
+    }
+    const sessions = this.sessions.get(key);
+    this.sessions.get(key)?.chats.set(newChatId, chat);
+  };
+
+	public async deleteSession(userId: string, sessionId: string): Promise<void> {
+    const key = this.generateKey(userId, sessionId);
+    this.sessions.delete(key);
+    this.userSessionIndex.delete(sessionId);
+  };
+
+	public async listSessions(userId: string): Promise<SessionMetadata[]> {
+    const sessions = this.userSessionIndex.get(userId);
+    if (sessions) {
+      return Array.from(sessions);
+    }
+    return [];
+  };
+}

package/index.ts

@@ -1,32 +1,2 @@
-import { randomUUID } from "node:crypto";
-import type { ChatObject, SessionObject } from "@ainetwork/adk/types/memory";
-import { BaseMemory } from "@ainetwork/adk/modules";
-
-export class InMemoryMemory extends BaseMemory {
-	public sessionHistory: Map<string, SessionObject>;
-
-	constructor() {
-		super();
-		this.sessionHistory = new Map<string, SessionObject>();
-	}
-
-	public async getSessionHistory(sessionId: string): Promise<SessionObject> {
-		return this.sessionHistory.get(sessionId) || { chats: {} };
-	}
-
-	public async updateSessionHistory(
-		sessionId: string,
-		chat: ChatObject,
-	): Promise<void> {
-		const newChatId = randomUUID();
-		const history = await this.getSessionHistory(sessionId);
-		history.chats[newChatId] = chat;
-		this.sessionHistory.set(sessionId, history);
-	}
-
-	public async storeQueryAndIntent(
-		query: string,
-		intent: string,
-		sessionId: string,
-	) {}
-}
+export { InMemorySession } from "./implements/session.memory";
+export { InMemoryIntent } from "./implements/intent.memory";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainetwork/adk-provider-memory-inmemory",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "author": "AI Network (https://ainetwork.ai)",
   "type": "module",
   "engines": {
@@ -21,7 +21,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@ainetwork/adk": "^0.1.2"
+    "@ainetwork/adk": "^0.1.7"
   },
   "devDependencies": {
     "typescript": "^5.0.0"
@@ -30,5 +30,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cb6205738fd84533ce56bbeeab00ea9dfe2aaf3a"
+  "gitHead": "4098aacea7a18099aa020ef5d331cdce0d59c3f3"
 }