opc-agent 1.3.0 → 1.3.2

package/src/core/rate-limiter.ts

@@ -1,128 +1,128 @@
-/**
- * Rate Limiter - Per-user and per-provider rate limiting with queuing.
- */
-
-interface RateLimitConfig {
-  maxRequests: number;
-  windowMs: number;
-}
-
-interface RateLimitEntry {
-  timestamps: number[];
-  queue: Array<{ resolve: () => void; reject: (err: Error) => void }>;
-}
-
-export class RateLimiter {
-  private userLimits: Map<string, RateLimitEntry> = new Map();
-  private providerLimits: Map<string, RateLimitEntry> = new Map();
-  private userConfig: RateLimitConfig;
-  private providerConfig: RateLimitConfig;
-  private maxQueueSize: number;
-
-  constructor(opts?: {
-    userLimit?: RateLimitConfig;
-    providerLimit?: RateLimitConfig;
-    maxQueueSize?: number;
-  }) {
-    this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
-    this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
-    this.maxQueueSize = opts?.maxQueueSize ?? 50;
-  }
-
-  /**
-   * Check if a request is allowed. If not, queues it with backpressure.
-   * Returns a promise that resolves when the request can proceed.
-   */
-  async acquire(userId: string, provider: string): Promise<void> {
-    await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
-    await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
-  }
-
-  private async checkLimit(
-    key: string,
-    limits: Map<string, RateLimitEntry>,
-    config: RateLimitConfig,
-    type: string,
-  ): Promise<void> {
-    let entry = limits.get(key);
-    if (!entry) {
-      entry = { timestamps: [], queue: [] };
-      limits.set(key, entry);
-    }
-
-    const now = Date.now();
-    // Prune old timestamps
-    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
-
-    if (entry.timestamps.length < config.maxRequests) {
-      entry.timestamps.push(now);
-      return;
-    }
-
-    // Rate limited - queue with backpressure
-    if (entry.queue.length >= this.maxQueueSize) {
-      throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      entry!.queue.push({ resolve, reject });
-      // Set timeout to process queue when window expires
-      const oldestTs = entry!.timestamps[0];
-      const waitMs = oldestTs + config.windowMs - now + 10;
-      setTimeout(() => {
-        this.processQueue(key, limits, config);
-      }, Math.max(waitMs, 100));
-    });
-  }
-
-  private processQueue(
-    key: string,
-    limits: Map<string, RateLimitEntry>,
-    config: RateLimitConfig,
-  ): void {
-    const entry = limits.get(key);
-    if (!entry || entry.queue.length === 0) return;
-
-    const now = Date.now();
-    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
-
-    while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
-      entry.timestamps.push(now);
-      const item = entry.queue.shift()!;
-      item.resolve();
-    }
-  }
-
-  /**
-   * Get current usage stats.
-   */
-  getUsage(userId?: string, provider?: string): {
-    user?: { used: number; limit: number; windowMs: number };
-    provider?: { used: number; limit: number; windowMs: number };
-  } {
-    const now = Date.now();
-    const result: any = {};
-
-    if (userId) {
-      const entry = this.userLimits.get(userId);
-      const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
-      result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
-    }
-
-    if (provider) {
-      const entry = this.providerLimits.get(provider);
-      const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
-      result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
-    }
-
-    return result;
-  }
-
-  /**
-   * Reset all limits.
-   */
-  reset(): void {
-    this.userLimits.clear();
-    this.providerLimits.clear();
-  }
-}
+/**
+ * Rate Limiter - Per-user and per-provider rate limiting with queuing.
+ */
+
+interface RateLimitConfig {
+  maxRequests: number;
+  windowMs: number;
+}
+
+interface RateLimitEntry {
+  timestamps: number[];
+  queue: Array<{ resolve: () => void; reject: (err: Error) => void }>;
+}
+
+export class RateLimiter {
+  private userLimits: Map<string, RateLimitEntry> = new Map();
+  private providerLimits: Map<string, RateLimitEntry> = new Map();
+  private userConfig: RateLimitConfig;
+  private providerConfig: RateLimitConfig;
+  private maxQueueSize: number;
+
+  constructor(opts?: {
+    userLimit?: RateLimitConfig;
+    providerLimit?: RateLimitConfig;
+    maxQueueSize?: number;
+  }) {
+    this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
+    this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
+    this.maxQueueSize = opts?.maxQueueSize ?? 50;
+  }
+
+  /**
+   * Check if a request is allowed. If not, queues it with backpressure.
+   * Returns a promise that resolves when the request can proceed.
+   */
+  async acquire(userId: string, provider: string): Promise<void> {
+    await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
+    await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
+  }
+
+  private async checkLimit(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+    type: string,
+  ): Promise<void> {
+    let entry = limits.get(key);
+    if (!entry) {
+      entry = { timestamps: [], queue: [] };
+      limits.set(key, entry);
+    }
+
+    const now = Date.now();
+    // Prune old timestamps
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    if (entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      return;
+    }
+
+    // Rate limited - queue with backpressure
+    if (entry.queue.length >= this.maxQueueSize) {
+      throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      entry!.queue.push({ resolve, reject });
+      // Set timeout to process queue when window expires
+      const oldestTs = entry!.timestamps[0];
+      const waitMs = oldestTs + config.windowMs - now + 10;
+      setTimeout(() => {
+        this.processQueue(key, limits, config);
+      }, Math.max(waitMs, 100));
+    });
+  }
+
+  private processQueue(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+  ): void {
+    const entry = limits.get(key);
+    if (!entry || entry.queue.length === 0) return;
+
+    const now = Date.now();
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      const item = entry.queue.shift()!;
+      item.resolve();
+    }
+  }
+
+  /**
+   * Get current usage stats.
+   */
+  getUsage(userId?: string, provider?: string): {
+    user?: { used: number; limit: number; windowMs: number };
+    provider?: { used: number; limit: number; windowMs: number };
+  } {
+    const now = Date.now();
+    const result: any = {};
+
+    if (userId) {
+      const entry = this.userLimits.get(userId);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
+      result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
+    }
+
+    if (provider) {
+      const entry = this.providerLimits.get(provider);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
+      result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
+    }
+
+    return result;
+  }
+
+  /**
+   * Reset all limits.
+   */
+  reset(): void {
+    this.userLimits.clear();
+    this.providerLimits.clear();
+  }
+}

package/src/core/room.ts

@@ -1,109 +1,109 @@
-import { EventEmitter } from 'events';
-import type { Message, IAgent } from './types';
-
-export interface RoomMessage {
-  from: string;
-  to?: string; // undefined = broadcast
-  topic?: string;
-  message: Message;
-}
-
-export class Room extends EventEmitter {
-  readonly name: string;
-  private agents: Map<string, IAgent> = new Map();
-  private subscriptions: Map<string, Set<string>> = new Map(); // topic -> agentNames
-
-  constructor(name: string) {
-    super();
-    this.name = name;
-  }
-
-  addAgent(agent: IAgent): void {
-    this.agents.set(agent.name, agent);
-    this.emit('agent:join', agent.name);
-  }
-
-  removeAgent(name: string): void {
-    this.agents.delete(name);
-    // Remove from all subscriptions
-    for (const [, subscribers] of this.subscriptions) {
-      subscribers.delete(name);
-    }
-    this.emit('agent:leave', name);
-  }
-
-  getAgents(): string[] {
-    return Array.from(this.agents.keys());
-  }
-
-  subscribe(agentName: string, topic: string): void {
-    if (!this.subscriptions.has(topic)) {
-      this.subscriptions.set(topic, new Set());
-    }
-    this.subscriptions.get(topic)!.add(agentName);
-  }
-
-  unsubscribe(agentName: string, topic: string): void {
-    this.subscriptions.get(topic)?.delete(agentName);
-  }
-
-  getSubscribers(topic: string): string[] {
-    return Array.from(this.subscriptions.get(topic) ?? []);
-  }
-
-  async send(roomMessage: RoomMessage): Promise<Message[]> {
-    const responses: Message[] = [];
-    this.emit('message', roomMessage);
-
-    if (roomMessage.to) {
-      // Direct message
-      const agent = this.agents.get(roomMessage.to);
-      if (agent) {
-        const response = await agent.handleMessage(roomMessage.message);
-        responses.push(response);
-      }
-    } else if (roomMessage.topic) {
-      // Topic-based pub/sub
-      const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
-      for (const name of subscribers) {
-        if (name === roomMessage.from) continue;
-        const agent = this.agents.get(name);
-        if (agent) {
-          const response = await agent.handleMessage(roomMessage.message);
-          responses.push(response);
-        }
-      }
-    } else {
-      // Broadcast to all except sender
-      for (const [name, agent] of this.agents) {
-        if (name === roomMessage.from) continue;
-        const response = await agent.handleMessage(roomMessage.message);
-        responses.push(response);
-      }
-    }
-
-    return responses;
-  }
-
-  async broadcast(from: string, content: string): Promise<Message[]> {
-    const message: Message = {
-      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'user',
-      content,
-      timestamp: Date.now(),
-      metadata: { room: this.name, from },
-    };
-    return this.send({ from, message });
-  }
-
-  async publishToTopic(from: string, topic: string, content: string): Promise<Message[]> {
-    const message: Message = {
-      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'user',
-      content,
-      timestamp: Date.now(),
-      metadata: { room: this.name, from, topic },
-    };
-    return this.send({ from, topic, message });
-  }
-}
+import { EventEmitter } from 'events';
+import type { Message, IAgent } from './types';
+
+export interface RoomMessage {
+  from: string;
+  to?: string; // undefined = broadcast
+  topic?: string;
+  message: Message;
+}
+
+export class Room extends EventEmitter {
+  readonly name: string;
+  private agents: Map<string, IAgent> = new Map();
+  private subscriptions: Map<string, Set<string>> = new Map(); // topic -> agentNames
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  addAgent(agent: IAgent): void {
+    this.agents.set(agent.name, agent);
+    this.emit('agent:join', agent.name);
+  }
+
+  removeAgent(name: string): void {
+    this.agents.delete(name);
+    // Remove from all subscriptions
+    for (const [, subscribers] of this.subscriptions) {
+      subscribers.delete(name);
+    }
+    this.emit('agent:leave', name);
+  }
+
+  getAgents(): string[] {
+    return Array.from(this.agents.keys());
+  }
+
+  subscribe(agentName: string, topic: string): void {
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, new Set());
+    }
+    this.subscriptions.get(topic)!.add(agentName);
+  }
+
+  unsubscribe(agentName: string, topic: string): void {
+    this.subscriptions.get(topic)?.delete(agentName);
+  }
+
+  getSubscribers(topic: string): string[] {
+    return Array.from(this.subscriptions.get(topic) ?? []);
+  }
+
+  async send(roomMessage: RoomMessage): Promise<Message[]> {
+    const responses: Message[] = [];
+    this.emit('message', roomMessage);
+
+    if (roomMessage.to) {
+      // Direct message
+      const agent = this.agents.get(roomMessage.to);
+      if (agent) {
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    } else if (roomMessage.topic) {
+      // Topic-based pub/sub
+      const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
+      for (const name of subscribers) {
+        if (name === roomMessage.from) continue;
+        const agent = this.agents.get(name);
+        if (agent) {
+          const response = await agent.handleMessage(roomMessage.message);
+          responses.push(response);
+        }
+      }
+    } else {
+      // Broadcast to all except sender
+      for (const [name, agent] of this.agents) {
+        if (name === roomMessage.from) continue;
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    }
+
+    return responses;
+  }
+
+  async broadcast(from: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from },
+    };
+    return this.send({ from, message });
+  }
+
+  async publishToTopic(from: string, topic: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from, topic },
+    };
+    return this.send({ from, topic, message });
+  }
+}