nostr-inbox 0.1.0 → 0.1.1

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "nostr-inbox",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Unified Nostr notification stream for AI agents — mentions, DMs, DVM requests, zaps, WoT attestations in one event loop",
   "main": "src/index.cjs",
+  "types": "src/index.d.cts",
   "bin": {
     "nostr-inbox": "src/cli.cjs"
   },

package/src/filters.cjs

@@ -85,25 +85,61 @@ function buildFilters(pubkey, channels = {}, since = null) {
   }
 
   // DVM requests: kind 5xxx tagged to us (we're a DVM provider)
+  // Split into small batches to avoid overwhelming relays
   if (dvmRequests) {
-    const dvmRequestKinds = [];
-    for (let k = 5000; k < 5100; k++) dvmRequestKinds.push(k);
-    filters.push({
-      kinds: dvmRequestKinds,
-      '#p': [pubkey],
-      ...sinceObj
-    });
+    const dvmKinds = channels.dvmKinds; // optional: specific DVM kinds to watch
+    if (dvmKinds && Array.isArray(dvmKinds)) {
+      // User specified exact kinds — use them directly
+      filters.push({
+        kinds: dvmKinds,
+        '#p': [pubkey],
+        ...sinceObj
+      });
+    } else {
+      // Common DVM kinds in small batches (max 20 per filter)
+      const commonDvmKinds = [
+        5000, 5001, 5002, 5003, 5004, 5005,  // generic
+        5050,                                   // text generation
+        5100,                                   // image generation
+        5200,                                   // text-to-speech
+        5250,                                   // speech-to-text
+        5300,                                   // content discovery
+        5301, 5302,                             // search, recommendations
+        5400, 5401,                             // data processing
+        5500, 5501,                             // translation
+        5900, 5901, 5902, 5903, 5904, 5905     // custom range
+      ];
+      filters.push({
+        kinds: commonDvmKinds,
+        '#p': [pubkey],
+        ...sinceObj
+      });
+    }
   }
 
   // DVM results: kind 6xxx tagged to us (we requested something)
   if (dvmResults) {
-    const dvmResultKinds = [];
-    for (let k = 6000; k < 6100; k++) dvmResultKinds.push(k);
-    filters.push({
-      kinds: dvmResultKinds,
-      '#p': [pubkey],
-      ...sinceObj
-    });
+    const dvmKinds = channels.dvmKinds;
+    if (dvmKinds && Array.isArray(dvmKinds)) {
+      // Map request kinds to result kinds
+      filters.push({
+        kinds: dvmKinds.map(k => k + 1000),
+        '#p': [pubkey],
+        ...sinceObj
+      });
+    } else {
+      const commonResultKinds = [
+        6000, 6001, 6002, 6003, 6004, 6005,
+        6050, 6100, 6200, 6250, 6300, 6301, 6302,
+        6400, 6401, 6500, 6501,
+        6900, 6901, 6902, 6903, 6904, 6905
+      ];
+      filters.push({
+        kinds: commonResultKinds,
+        '#p': [pubkey],
+        ...sinceObj
+      });
+    }
   }
 
   // Zaps: receipts tagged to our pubkey

package/src/index.d.cts

@@ -0,0 +1,137 @@
+// Type definitions for nostr-inbox
+
+import { EventEmitter } from 'events';
+
+export interface NostrEvent {
+  id: string;
+  pubkey: string;
+  kind: number;
+  created_at: number;
+  tags: string[][];
+  content: string;
+  sig: string;
+}
+
+export type NotificationType =
+  | 'mention' | 'dm' | 'dvm_request' | 'dvm_result' | 'dvm_feedback'
+  | 'zap' | 'reaction' | 'trust' | 'trust_network'
+  | 'marketplace_bid' | 'marketplace_delivery' | 'marketplace_resolution'
+  | 'unknown';
+
+export type Priority = 'high' | 'medium' | 'low';
+
+export interface Notification {
+  id: string;
+  type: NotificationType;
+  priority: Priority;
+  from: string;
+  content: string;
+  kind: number;
+  tags: string[][];
+  createdAt: number;
+  raw: NostrEvent;
+  dvmKind?: number;
+}
+
+export interface Channels {
+  mentions?: boolean;
+  dms?: boolean;
+  dvmRequests?: boolean;
+  dvmResults?: boolean;
+  zaps?: boolean;
+  reactions?: boolean;
+  trust?: boolean;
+  marketplace?: boolean;
+  dvmKinds?: number[];
+}
+
+export interface InboxOptions {
+  pubkey: string;
+  relays?: string[];
+  channels?: Channels;
+  since?: number;
+  dedup?: boolean;
+  onEvent?: (notification: Notification) => void;
+  onError?: (error: { relay: string; error: string }) => void;
+  reconnectMs?: number;
+  connectTimeoutMs?: number;
+}
+
+export interface InboxStatus {
+  running: boolean;
+  relays: {
+    connected: number;
+    total: number;
+    urls: string[];
+  };
+  seen: number;
+  latestTimestamp: number;
+  channels: Channels;
+}
+
+export interface Inbox {
+  start(): Promise<EventEmitter>;
+  stop(): void;
+  status(): InboxStatus;
+  on(event: 'notification', handler: (n: Notification) => void): void;
+  on(event: 'urgent', handler: (n: Notification) => void): void;
+  on(event: NotificationType, handler: (n: Notification) => void): void;
+  on(event: 'connected', handler: (info: { relay: string }) => void): void;
+  on(event: 'started', handler: (info: { connected: number; total: number }) => void): void;
+  on(event: 'stopped', handler: () => void): void;
+  on(event: 'synced', handler: (info: { relay: string }) => void): void;
+  on(event: 'error', handler: (error: { relay: string; error: string }) => void): void;
+  off(event: string, handler: Function): void;
+  once(event: string, handler: Function): void;
+  waitFor(type: NotificationType, timeoutMs?: number): Promise<Notification>;
+  collect(durationMs?: number, filter?: (n: Notification) => boolean): Promise<Notification[]>;
+  emitter: EventEmitter;
+}
+
+export interface PollOptions {
+  pubkey: string;
+  relays?: string[];
+  channels?: Channels;
+  since?: number;
+  timeoutMs?: number;
+}
+
+export interface PollResult {
+  total: number;
+  urgent: number;
+  notifications: Notification[];
+  byType: Record<NotificationType, Notification[]>;
+  since: number;
+  queriedAt: number;
+}
+
+export interface Classification {
+  type: NotificationType;
+  priority: Priority;
+  dvmKind?: number;
+}
+
+export function createInbox(opts: InboxOptions): Inbox;
+export function poll(opts: PollOptions): Promise<PollResult>;
+export function buildFilters(pubkey: string, channels?: Channels, since?: number): object[];
+export function classifyEvent(event: NostrEvent, myPubkey: string): Classification;
+
+export const KINDS: {
+  TEXT_NOTE: 1;
+  DM_ENCRYPTED: 4;
+  REACTION: 7;
+  DVM_REQUEST_BASE: 5000;
+  DVM_RESULT_BASE: 6000;
+  DVM_FEEDBACK: 7000;
+  ZAP_RECEIPT: 9735;
+  ZAP_REQUEST: 9734;
+  LABEL: 1985;
+  GIFT_WRAP: 1059;
+  SEAL: 13;
+  AGENT_SERVICE: 38990;
+  TASK: 30950;
+  BID: 950;
+  DELIVERY: 951;
+  RESOLUTION: 952;
+  COMMENT: 1111;
+};