agent-inbox 0.0.1 → 0.1.2

package/src/storage/memory.ts

@@ -0,0 +1,145 @@
+import type {
+  Agent,
+  Message,
+  Conversation,
+  Turn,
+  Thread,
+} from "../types.js";
+import type { Storage, InboxQuery, ThreadQuery } from "./interface.js";
+
+export class InMemoryStorage implements Storage {
+  private agents = new Map<string, Agent>();
+  private messages = new Map<string, Message>();
+  private conversations = new Map<string, Conversation>();
+  private turns: Turn[] = [];
+  private threads = new Map<string, Thread>();
+
+  // --- Agents ---
+
+  getAgent(agentId: string): Agent | undefined {
+    return this.agents.get(agentId);
+  }
+
+  putAgent(agent: Agent): void {
+    this.agents.set(agent.agent_id, agent);
+  }
+
+  listAgents(scope?: string): Agent[] {
+    const all = Array.from(this.agents.values());
+    if (!scope) return all;
+    return all.filter((a) => a.scope === scope);
+  }
+
+  removeAgent(agentId: string): boolean {
+    return this.agents.delete(agentId);
+  }
+
+  // --- Messages ---
+
+  getMessage(id: string): Message | undefined {
+    return this.messages.get(id);
+  }
+
+  putMessage(message: Message): Message {
+    this.messages.set(message.id, message);
+    return message;
+  }
+
+  getInbox(agentId: string, opts?: InboxQuery): Message[] {
+    const results: Message[] = [];
+    for (const msg of this.messages.values()) {
+      const recipient = msg.recipients.find((r) => r.agent_id === agentId);
+      if (!recipient) continue;
+      if (opts?.unreadOnly && recipient.read_at) continue;
+      if (opts?.since && msg.created_at < opts.since) continue;
+      results.push(msg);
+    }
+    results.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    if (opts?.limit) return results.slice(0, opts.limit);
+    return results;
+  }
+
+  getThread(query: ThreadQuery): Message[] {
+    const results: Message[] = [];
+    for (const msg of this.messages.values()) {
+      if (msg.thread_tag === query.threadTag && msg.scope === query.scope) {
+        results.push(msg);
+      }
+    }
+    return results.sort((a, b) => a.created_at.localeCompare(b.created_at));
+  }
+
+  getSentMessages(agentId: string, limit?: number): Message[] {
+    const results: Message[] = [];
+    for (const msg of this.messages.values()) {
+      if (msg.sender_id === agentId) results.push(msg);
+    }
+    results.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    if (limit) return results.slice(0, limit);
+    return results;
+  }
+
+  searchMessages(query: string, scope?: string): Message[] {
+    const lower = query.toLowerCase();
+    const results: Message[] = [];
+    for (const msg of this.messages.values()) {
+      if (scope && msg.scope !== scope) continue;
+      const text =
+        msg.content.type === "text" ? (msg.content as { text: string }).text : "";
+      const subject = msg.subject ?? "";
+      if (
+        text.toLowerCase().includes(lower) ||
+        subject.toLowerCase().includes(lower)
+      ) {
+        results.push(msg);
+      }
+    }
+    return results.sort((a, b) => a.created_at.localeCompare(b.created_at));
+  }
+
+  // --- Conversations ---
+
+  getConversation(id: string): Conversation | undefined {
+    return this.conversations.get(id);
+  }
+
+  putConversation(conversation: Conversation): Conversation {
+    this.conversations.set(conversation.id, conversation);
+    return conversation;
+  }
+
+  listConversations(scope?: string): Conversation[] {
+    const all = Array.from(this.conversations.values());
+    if (!scope) return all;
+    return all.filter((c) => c.scope === scope);
+  }
+
+  // --- Turns ---
+
+  addTurn(turn: Turn): void {
+    this.turns.push(turn);
+  }
+
+  getTurns(conversationId: string): Turn[] {
+    return this.turns
+      .filter((t) => t.conversation_id === conversationId)
+      .sort((a, b) => a.created_at.localeCompare(b.created_at));
+  }
+
+  // --- Threads ---
+
+  getThread2(id: string): Thread | undefined {
+    return this.threads.get(id);
+  }
+
+  putThread(thread: Thread): Thread {
+    this.threads.set(thread.id, thread);
+    return thread;
+  }
+
+  getThreadsByConversation(conversationId: string): Thread[] {
+    return Array.from(this.threads.values()).filter(
+      (t) => t.conversation_id === conversationId
+    );
+  }
+}