opc-agent 4.1.1 → 4.1.3

package/src/core/orchestrator.ts

@@ -1,215 +0,0 @@
-import { EventEmitter } from 'events';
-import type { AgentContext, Message } from './types';
-
-/**
- * Multi-Agent Orchestrator — v0.8.0
- * Routes messages to specialized sub-agents, supports parallel execution and handoffs.
- */
-
-export interface AgentNode {
-  id: string;
-  name: string;
-  description: string;
-  /** Patterns or intents this agent handles */
-  routes: string[];
-  /** Function that processes a message and returns a response */
-  handler: (context: AgentContext, message: Message) => Promise<Message>;
-  /** Priority for routing conflicts (higher wins) */
-  priority?: number;
-}
-
-export interface OrchestratorWorkflow {
-  name: string;
-  description?: string;
-  /** Ordered list of agent IDs for sequential execution */
-  steps?: string[];
-  /** List of agent IDs for parallel execution */
-  parallel?: string[];
-  /** Router config: auto-route based on message content */
-  router?: {
-    agents: string[];
-    fallback?: string;
-  };
-}
-
-export interface HandoffRequest {
-  fromAgent: string;
-  toAgent: string;
-  context: AgentContext;
-  reason: string;
-}
-
-export interface OrchestratorConfig {
-  agents: AgentNode[];
-  workflows?: OrchestratorWorkflow[];
-  defaultWorkflow?: string;
-  maxParallel?: number;
-}
-
-export class Orchestrator extends EventEmitter {
-  private agents: Map<string, AgentNode> = new Map();
-  private workflows: Map<string, OrchestratorWorkflow> = new Map();
-  private defaultWorkflow?: string;
-  private maxParallel: number;
-
-  constructor(config: OrchestratorConfig) {
-    super();
-    this.maxParallel = config.maxParallel ?? 5;
-    this.defaultWorkflow = config.defaultWorkflow;
-
-    for (const agent of config.agents) {
-      this.agents.set(agent.id, agent);
-    }
-    for (const wf of config.workflows ?? []) {
-      this.workflows.set(wf.name, wf);
-    }
-  }
-
-  /** Register a new agent node */
-  registerAgent(agent: AgentNode): void {
-    this.agents.set(agent.id, agent);
-    this.emit('agent:registered', agent.id);
-  }
-
-  /** Unregister an agent */
-  unregisterAgent(id: string): void {
-    this.agents.delete(id);
-    this.emit('agent:unregistered', id);
-  }
-
-  /** Route a message to the best-matching agent */
-  route(message: Message): AgentNode | undefined {
-    const content = message.content.toLowerCase();
-    let bestMatch: AgentNode | undefined;
-    let bestPriority = -1;
-
-    for (const agent of this.agents.values()) {
-      for (const route of agent.routes) {
-        if (content.includes(route.toLowerCase()) || new RegExp(route, 'i').test(content)) {
-          const priority = agent.priority ?? 0;
-          if (priority > bestPriority) {
-            bestMatch = agent;
-            bestPriority = priority;
-          }
-          break;
-        }
-      }
-    }
-    return bestMatch;
-  }
-
-  /** Execute a single agent */
-  async executeAgent(agentId: string, context: AgentContext, message: Message): Promise<Message> {
-    const agent = this.agents.get(agentId);
-    if (!agent) throw new Error(`Agent not found: ${agentId}`);
-    this.emit('agent:execute', agentId, message);
-    const result = await agent.handler(context, message);
-    this.emit('agent:complete', agentId, result);
-    return result;
-  }
-
-  /** Run multiple agents in parallel */
-  async executeParallel(
-    agentIds: string[],
-    context: AgentContext,
-    message: Message
-  ): Promise<Map<string, Message>> {
-    const results = new Map<string, Message>();
-    const batches: string[][] = [];
-
-    // Batch by maxParallel
-    for (let i = 0; i < agentIds.length; i += this.maxParallel) {
-      batches.push(agentIds.slice(i, i + this.maxParallel));
-    }
-
-    for (const batch of batches) {
-      const promises = batch.map(async (id) => {
-        const result = await this.executeAgent(id, context, message);
-        results.set(id, result);
-      });
-      await Promise.all(promises);
-    }
-
-    return results;
-  }
-
-  /** Execute a named workflow */
-  async executeWorkflow(
-    workflowName: string,
-    context: AgentContext,
-    message: Message
-  ): Promise<Message[]> {
-    const wf = this.workflows.get(workflowName);
-    if (!wf) throw new Error(`Workflow not found: ${workflowName}`);
-
-    const results: Message[] = [];
-
-    // Sequential steps
-    if (wf.steps) {
-      let currentMessage = message;
-      for (const agentId of wf.steps) {
-        const result = await this.executeAgent(agentId, context, currentMessage);
-        results.push(result);
-        currentMessage = result; // chain output → next input
-      }
-    }
-
-    // Parallel execution
-    if (wf.parallel) {
-      const parallelResults = await this.executeParallel(wf.parallel, context, message);
-      results.push(...parallelResults.values());
-    }
-
-    // Router-based
-    if (wf.router) {
-      const matched = this.route(message);
-      const targetId = matched && wf.router.agents.includes(matched.id)
-        ? matched.id
-        : wf.router.fallback;
-      if (targetId) {
-        const result = await this.executeAgent(targetId, context, message);
-        results.push(result);
-      }
-    }
-
-    return results;
-  }
-
-  /** Hand off conversation from one agent to another */
-  async handoff(request: HandoffRequest): Promise<Message> {
-    this.emit('agent:handoff', request);
-    const { toAgent, context } = request;
-    const lastMessage = context.messages[context.messages.length - 1];
-    if (!lastMessage) throw new Error('No message in context for handoff');
-    return this.executeAgent(toAgent, context, lastMessage);
-  }
-
-  /** Process an incoming message using the default workflow or routing */
-  async process(context: AgentContext, message: Message): Promise<Message[]> {
-    if (this.defaultWorkflow) {
-      return this.executeWorkflow(this.defaultWorkflow, context, message);
-    }
-
-    // Fallback: route to single agent
-    const agent = this.route(message);
-    if (agent) {
-      const result = await this.executeAgent(agent.id, context, message);
-      return [result];
-    }
-
-    return [{
-      id: `orch-${Date.now()}`,
-      role: 'assistant',
-      content: 'No agent available to handle this request.',
-      timestamp: Date.now(),
-    }];
-  }
-
-  getAgents(): AgentNode[] {
-    return Array.from(this.agents.values());
-  }
-
-  getWorkflows(): OrchestratorWorkflow[] {
-    return Array.from(this.workflows.values());
-  }
-}

package/src/core/performance.ts

@@ -1,187 +0,0 @@
-import { Logger } from '../core/logger';
-
-// ── Connection Pool ─────────────────────────────────────────
-
-export interface PooledConnection {
-  id: string;
-  provider: string;
-  createdAt: number;
-  lastUsedAt: number;
-  inUse: boolean;
-}
-
-export class ConnectionPool {
-  private pool: Map<string, PooledConnection[]> = new Map();
-  private maxPerProvider: number;
-  private ttlMs: number;
-  private logger = new Logger('connection-pool');
-
-  constructor(maxPerProvider = 5, ttlMs = 300000) {
-    this.maxPerProvider = maxPerProvider;
-    this.ttlMs = ttlMs;
-  }
-
-  acquire(provider: string): PooledConnection {
-    const connections = this.pool.get(provider) ?? [];
-    
-    // Cleanup expired
-    const now = Date.now();
-    const active = connections.filter(c => now - c.createdAt < this.ttlMs);
-    
-    // Find available
-    const available = active.find(c => !c.inUse);
-    if (available) {
-      available.inUse = true;
-      available.lastUsedAt = now;
-      return available;
-    }
-
-    // Create new if under limit
-    if (active.length < this.maxPerProvider) {
-      const conn: PooledConnection = {
-        id: `conn_${now}_${Math.random().toString(36).slice(2, 8)}`,
-        provider,
-        createdAt: now,
-        lastUsedAt: now,
-        inUse: true,
-      };
-      active.push(conn);
-      this.pool.set(provider, active);
-      return conn;
-    }
-
-    // Wait for one (return oldest used for now)
-    const oldest = active.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
-    oldest.inUse = true;
-    oldest.lastUsedAt = now;
-    return oldest;
-  }
-
-  release(id: string): void {
-    for (const connections of this.pool.values()) {
-      const conn = connections.find(c => c.id === id);
-      if (conn) {
-        conn.inUse = false;
-        return;
-      }
-    }
-  }
-
-  getStats(): Record<string, { total: number; inUse: number }> {
-    const stats: Record<string, { total: number; inUse: number }> = {};
-    for (const [provider, connections] of this.pool) {
-      stats[provider] = {
-        total: connections.length,
-        inUse: connections.filter(c => c.inUse).length,
-      };
-    }
-    return stats;
-  }
-
-  drain(): void {
-    this.pool.clear();
-  }
-}
-
-// ── Request Batcher ─────────────────────────────────────────
-
-export interface BatchRequest<T> {
-  payload: T;
-  resolve: (result: unknown) => void;
-  reject: (error: Error) => void;
-}
-
-export class RequestBatcher<T> {
-  private queue: BatchRequest<T>[] = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private maxBatchSize: number;
-  private delayMs: number;
-  private processor: (batch: T[]) => Promise<unknown[]>;
-  private logger = new Logger('batcher');
-
-  constructor(
-    processor: (batch: T[]) => Promise<unknown[]>,
-    maxBatchSize = 10,
-    delayMs = 50,
-  ) {
-    this.processor = processor;
-    this.maxBatchSize = maxBatchSize;
-    this.delayMs = delayMs;
-  }
-
-  add(payload: T): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      this.queue.push({ payload, resolve, reject });
-
-      if (this.queue.length >= this.maxBatchSize) {
-        this.flush();
-      } else if (!this.timer) {
-        this.timer = setTimeout(() => this.flush(), this.delayMs);
-      }
-    });
-  }
-
-  async flush(): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-
-    if (this.queue.length === 0) return;
-
-    const batch = this.queue.splice(0, this.maxBatchSize);
-    try {
-      const results = await this.processor(batch.map(b => b.payload));
-      batch.forEach((req, i) => req.resolve(results[i]));
-    } catch (err) {
-      batch.forEach(req => req.reject(err as Error));
-    }
-  }
-
-  get pending(): number {
-    return this.queue.length;
-  }
-}
-
-// ── Lazy Loader ─────────────────────────────────────────────
-
-export class LazyLoader<T> {
-  private cache: Map<string, T> = new Map();
-  private loaders: Map<string, () => Promise<T>> = new Map();
-
-  register(name: string, loader: () => Promise<T>): void {
-    this.loaders.set(name, loader);
-  }
-
-  async get(name: string): Promise<T> {
-    const cached = this.cache.get(name);
-    if (cached) return cached;
-
-    const loader = this.loaders.get(name);
-    if (!loader) throw new Error(`No loader registered for "${name}"`);
-
-    const instance = await loader();
-    this.cache.set(name, instance);
-    return instance;
-  }
-
-  isLoaded(name: string): boolean {
-    return this.cache.has(name);
-  }
-
-  evict(name: string): void {
-    this.cache.delete(name);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get loadedCount(): number {
-    return this.cache.size;
-  }
-
-  get registeredCount(): number {
-    return this.loaders.size;
-  }
-}

package/src/core/profiles.ts

@@ -1,122 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// ─── Types ───────────────────────────────────────────────────
-
-export interface ProfileConfig {
-  model?: string;
-  systemPrompt?: string;
-  temperature?: number;
-  [key: string]: unknown;
-}
-
-export interface Profile {
-  name: string;
-  config: ProfileConfig;
-  createdAt: number;
-  lastUsed: number;
-}
-
-// ─── ProfileManager ─────────────────────────────────────────
-
-export class ProfileManager {
-  private profilesDir: string;
-  private currentName: string = 'default';
-
-  constructor(baseDir?: string) {
-    this.profilesDir = baseDir ?? path.join(os.homedir(), '.opc', 'profiles');
-    this.ensureDir(this.profilesDir);
-
-    // Load current profile pointer
-    const pointerFile = path.join(this.profilesDir, '.current');
-    if (fs.existsSync(pointerFile)) {
-      this.currentName = fs.readFileSync(pointerFile, 'utf-8').trim();
-    }
-  }
-
-  private ensureDir(dir: string): void {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-
-  private profileDir(name: string): string {
-    return path.join(this.profilesDir, name);
-  }
-
-  private profileFile(name: string): string {
-    return path.join(this.profileDir(name), 'profile.json');
-  }
-
-  create(name: string, config: ProfileConfig = {}): Profile {
-    const dir = this.profileDir(name);
-    if (fs.existsSync(dir)) {
-      throw new Error(`Profile '${name}' already exists`);
-    }
-    this.ensureDir(dir);
-    // Also create memory and sessions dirs
-    this.ensureDir(path.join(dir, 'memory'));
-    this.ensureDir(path.join(dir, 'sessions'));
-
-    const profile: Profile = {
-      name,
-      config,
-      createdAt: Date.now(),
-      lastUsed: Date.now(),
-    };
-    fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
-    return profile;
-  }
-
-  switch(name: string): void {
-    if (!fs.existsSync(this.profileDir(name))) {
-      throw new Error(`Profile '${name}' does not exist`);
-    }
-    this.currentName = name;
-    fs.writeFileSync(path.join(this.profilesDir, '.current'), name);
-
-    // Update lastUsed
-    const profile = this.get(name);
-    profile.lastUsed = Date.now();
-    fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
-  }
-
-  list(): Profile[] {
-    if (!fs.existsSync(this.profilesDir)) return [];
-    return fs.readdirSync(this.profilesDir)
-      .filter(f => {
-        const full = path.join(this.profilesDir, f);
-        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'profile.json'));
-      })
-      .map(f => this.get(f));
-  }
-
-  get(name: string): Profile {
-    const file = this.profileFile(name);
-    if (!fs.existsSync(file)) {
-      throw new Error(`Profile '${name}' not found`);
-    }
-    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-  }
-
-  delete(name: string): void {
-    if (name === this.currentName) {
-      throw new Error(`Cannot delete the current active profile '${name}'`);
-    }
-    const dir = this.profileDir(name);
-    if (!fs.existsSync(dir)) {
-      throw new Error(`Profile '${name}' does not exist`);
-    }
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-
-  current(): Profile {
-    try {
-      return this.get(this.currentName);
-    } catch {
-      // Auto-create default
-      return this.create(this.currentName);
-    }
-  }
-}

package/src/core/rate-limiter.ts

@@ -1,128 +0,0 @@
-/**
- * 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();
-  }
-}