agent-relay 1.3.0 → 1.3.2

package/dist/daemon/delivery-tracker.js

@@ -0,0 +1,104 @@
+import { routerLog } from '../utils/logger.js';
+export const DEFAULT_DELIVERY_OPTIONS = {
+    ackTimeoutMs: 5000,
+    maxAttempts: 5,
+    deliveryTtlMs: 60_000,
+};
+export class DeliveryTracker {
+    pendingDeliveries = new Map();
+    deliveryOptions;
+    storage;
+    getConnection;
+    constructor(options) {
+        this.storage = options.storage;
+        this.deliveryOptions = { ...DEFAULT_DELIVERY_OPTIONS, ...options.delivery };
+        this.getConnection = options.getConnection;
+    }
+    get pendingCount() {
+        return this.pendingDeliveries.size;
+    }
+    track(target, deliver) {
+        const pending = {
+            envelope: deliver,
+            connectionId: target.id,
+            attempts: 1,
+            firstSentAt: Date.now(),
+        };
+        pending.timer = this.scheduleRetry(deliver.id);
+        this.pendingDeliveries.set(deliver.id, pending);
+    }
+    handleAck(connectionId, ackId) {
+        const pending = this.pendingDeliveries.get(ackId);
+        if (!pending)
+            return;
+        // Only accept ACKs from the same connection that received the deliver
+        if (pending.connectionId !== connectionId)
+            return;
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        this.pendingDeliveries.delete(ackId);
+        const statusUpdate = this.storage?.updateMessageStatus?.(ackId, 'acked');
+        if (statusUpdate instanceof Promise) {
+            statusUpdate.catch(err => {
+                routerLog.error('Failed to record ACK status', { error: String(err) });
+            });
+        }
+        routerLog.debug(`ACK received for ${ackId}`);
+    }
+    clearPendingForConnection(connectionId) {
+        for (const [id, pending] of this.pendingDeliveries.entries()) {
+            if (pending.connectionId === connectionId) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                this.pendingDeliveries.delete(id);
+            }
+        }
+    }
+    scheduleRetry(deliverId) {
+        return setTimeout(() => {
+            const pending = this.pendingDeliveries.get(deliverId);
+            if (!pending)
+                return;
+            const now = Date.now();
+            const elapsed = now - pending.firstSentAt;
+            if (elapsed > this.deliveryOptions.deliveryTtlMs) {
+                routerLog.warn(`Dropping ${deliverId} after TTL`, { ttlMs: this.deliveryOptions.deliveryTtlMs });
+                this.pendingDeliveries.delete(deliverId);
+                this.markFailed(deliverId);
+                return;
+            }
+            if (pending.attempts >= this.deliveryOptions.maxAttempts) {
+                routerLog.warn(`Dropping ${deliverId} after max attempts`, { maxAttempts: this.deliveryOptions.maxAttempts });
+                this.pendingDeliveries.delete(deliverId);
+                this.markFailed(deliverId);
+                return;
+            }
+            const target = this.getConnection(pending.connectionId);
+            if (!target) {
+                routerLog.warn(`Dropping ${deliverId} - connection unavailable`);
+                this.pendingDeliveries.delete(deliverId);
+                this.markFailed(deliverId);
+                return;
+            }
+            pending.attempts++;
+            const sent = target.send(pending.envelope);
+            if (!sent) {
+                routerLog.warn(`Retry failed for ${deliverId}`, { attempt: pending.attempts });
+            }
+            else {
+                routerLog.debug(`Retried ${deliverId}`, { attempt: pending.attempts });
+            }
+            pending.timer = this.scheduleRetry(deliverId);
+        }, this.deliveryOptions.ackTimeoutMs);
+    }
+    markFailed(deliverId) {
+        const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
+        if (statusUpdate instanceof Promise) {
+            statusUpdate.catch(err => {
+                routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
+            });
+        }
+    }
+}
+//# sourceMappingURL=delivery-tracker.js.map

package/dist/daemon/enhanced-features.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Enhanced Features Integration Module
+ *
+ * Wires together the new performance and reliability features:
+ * - Precompiled regex patterns
+ * - Agent authentication with signing
+ * - Dead Letter Queue
+ * - Context compaction
+ * - Consensus mechanism
+ *
+ * This module provides a unified interface for integrating
+ * these features into the existing daemon and router.
+ */
+import type { Database as BetterSqlite3Database } from 'better-sqlite3';
+import type { Pool as PgPool } from 'pg';
+import { getCompiledPatterns, isInstructionalTextFast, isPlaceholderTargetFast, stripAnsiFast, StaticPatterns } from '../utils/precompiled-patterns.js';
+import { AgentSigningManager, loadSigningConfig, attachSignature, extractSignature, type AgentSigningConfig, type SignedMessage } from './agent-signing.js';
+import { SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, type DLQStorageAdapter, type DLQConfig, type DeadLetter, type DLQStats } from '../storage/dlq-adapter.js';
+import { ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, formatTokenCount, type Message, type CompactionConfig, type CompactionResult } from '../memory/context-compaction.js';
+import { ConsensusEngine, createConsensusEngine, formatProposalMessage, parseVoteCommand, formatResultMessage, type Proposal, type ConsensusResult, type ConsensusConfig, type VoteValue } from './consensus.js';
+export interface EnhancedFeaturesConfig {
+    /** Pattern matching configuration */
+    patterns?: {
+        relayPrefix?: string;
+        thinkingPrefix?: string;
+    };
+    /** Signing configuration (or path to config file) */
+    signing?: Partial<AgentSigningConfig> | string;
+    /** DLQ configuration */
+    dlq?: Partial<DLQConfig> & {
+        /** Storage type */
+        type?: 'sqlite' | 'postgres' | 'memory';
+        /** SQLite database (if type is sqlite) */
+        sqlite?: BetterSqlite3Database;
+        /** PostgreSQL pool (if type is postgres) */
+        postgres?: PgPool;
+    };
+    /** Context compaction configuration */
+    compaction?: Partial<CompactionConfig>;
+    /** Consensus configuration */
+    consensus?: Partial<ConsensusConfig>;
+}
+export interface EnhancedFeatures {
+    /** Precompiled pattern matching */
+    patterns: {
+        compiled: ReturnType<typeof getCompiledPatterns>;
+        isInstructionalText: typeof isInstructionalTextFast;
+        isPlaceholderTarget: typeof isPlaceholderTargetFast;
+        stripAnsi: typeof stripAnsiFast;
+        static: typeof StaticPatterns;
+    };
+    /** Agent signing manager */
+    signing: AgentSigningManager;
+    /** Dead Letter Queue */
+    dlq: DLQStorageAdapter;
+    /** Context compactor */
+    compaction: ContextCompactor;
+    /** Consensus engine */
+    consensus: ConsensusEngine;
+    /** Cleanup function */
+    cleanup: () => Promise<void>;
+}
+/**
+ * Initialize all enhanced features.
+ */
+export declare function initEnhancedFeatures(config?: EnhancedFeaturesConfig): Promise<EnhancedFeatures>;
+/**
+ * Handle failed message delivery by adding to DLQ.
+ */
+export declare function handleDeliveryFailure(dlq: DLQStorageAdapter, envelope: {
+    id: string;
+    from: string;
+    to: string;
+    topic?: string;
+    payload: {
+        kind: string;
+        body: string;
+        data?: Record<string, unknown>;
+        thread?: string;
+    };
+    ts: number;
+}, reason: 'max_retries_exceeded' | 'ttl_expired' | 'connection_lost' | 'target_not_found', attemptCount: number, errorMessage?: string): Promise<DeadLetter>;
+/**
+ * Sign an outgoing envelope if signing is enabled.
+ */
+export declare function signEnvelope<T extends Record<string, unknown>>(signing: AgentSigningManager, envelope: T, agentName: string): T;
+/**
+ * Verify an incoming envelope signature.
+ */
+export declare function verifyEnvelope(signing: AgentSigningManager, envelope: Record<string, unknown>): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Process a potential vote command from a relay message.
+ */
+export declare function processVoteMessage(consensus: ConsensusEngine, from: string, body: string): {
+    processed: boolean;
+    result?: ReturnType<ConsensusEngine['vote']>;
+};
+/**
+ * Create a proposal and format it for broadcast.
+ */
+export declare function createAndBroadcastProposal(consensus: ConsensusEngine, options: Parameters<ConsensusEngine['createProposal']>[0]): {
+    proposal: Proposal;
+    message: string;
+};
+/**
+ * Check if context needs compaction and compact if necessary.
+ */
+export declare function manageContext(compactor: ContextCompactor, messages: Message[]): {
+    messages: Message[];
+    compacted: boolean;
+    result?: CompactionResult;
+    budget: ReturnType<ContextCompactor['getTokenBudget']>;
+};
+export { getCompiledPatterns, isInstructionalTextFast, isPlaceholderTargetFast, stripAnsiFast, StaticPatterns, AgentSigningManager, loadSigningConfig, attachSignature, extractSignature, type AgentSigningConfig, type SignedMessage, SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, type DLQStorageAdapter, type DLQConfig, type DeadLetter, type DLQStats, ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, formatTokenCount, type Message, type CompactionConfig, type CompactionResult, ConsensusEngine, createConsensusEngine, formatProposalMessage, parseVoteCommand, formatResultMessage, type Proposal, type ConsensusResult, type ConsensusConfig, type VoteValue, };
+//# sourceMappingURL=enhanced-features.d.ts.map

package/dist/daemon/enhanced-features.js

@@ -0,0 +1,178 @@
+/**
+ * Enhanced Features Integration Module
+ *
+ * Wires together the new performance and reliability features:
+ * - Precompiled regex patterns
+ * - Agent authentication with signing
+ * - Dead Letter Queue
+ * - Context compaction
+ * - Consensus mechanism
+ *
+ * This module provides a unified interface for integrating
+ * these features into the existing daemon and router.
+ */
+// Import new modules
+import { getCompiledPatterns, isInstructionalTextFast, isPlaceholderTargetFast, stripAnsiFast, StaticPatterns, } from '../utils/precompiled-patterns.js';
+import { AgentSigningManager, loadSigningConfig, attachSignature, extractSignature, } from './agent-signing.js';
+import { SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, } from '../storage/dlq-adapter.js';
+import { ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, formatTokenCount, } from '../memory/context-compaction.js';
+import { ConsensusEngine, createConsensusEngine, formatProposalMessage, parseVoteCommand, formatResultMessage, } from './consensus.js';
+// =============================================================================
+// Factory Function
+// =============================================================================
+/**
+ * Initialize all enhanced features.
+ */
+export async function initEnhancedFeatures(config = {}) {
+    // Initialize pattern matching
+    const patterns = {
+        compiled: getCompiledPatterns(config.patterns?.relayPrefix ?? '->relay:', config.patterns?.thinkingPrefix ?? '->thinking:'),
+        isInstructionalText: isInstructionalTextFast,
+        isPlaceholderTarget: isPlaceholderTargetFast,
+        stripAnsi: stripAnsiFast,
+        static: StaticPatterns,
+    };
+    // Initialize signing
+    const signingConfig = typeof config.signing === 'string'
+        ? loadSigningConfig(config.signing)
+        : { ...loadSigningConfig(), ...config.signing };
+    const signing = new AgentSigningManager(signingConfig);
+    // Initialize DLQ
+    let dlq;
+    const dlqConfig = config.dlq ?? {};
+    if (dlqConfig.type === 'postgres' && dlqConfig.postgres) {
+        dlq = new PostgresDLQAdapter(dlqConfig.postgres);
+    }
+    else if (dlqConfig.type === 'sqlite' && dlqConfig.sqlite) {
+        dlq = new SQLiteDLQAdapter(dlqConfig.sqlite);
+    }
+    else if (dlqConfig.type === 'memory' || (!dlqConfig.sqlite && !dlqConfig.postgres)) {
+        dlq = new InMemoryDLQAdapter();
+    }
+    else {
+        dlq = new InMemoryDLQAdapter();
+    }
+    await dlq.init();
+    // Initialize context compaction
+    const compaction = createContextCompactor(config.compaction);
+    // Initialize consensus
+    const consensus = createConsensusEngine(config.consensus);
+    // Cleanup function
+    const cleanup = async () => {
+        await dlq.close();
+        consensus.cleanup();
+    };
+    return {
+        patterns,
+        signing,
+        dlq,
+        compaction,
+        consensus,
+        cleanup,
+    };
+}
+// =============================================================================
+// Router Integration Helpers
+// =============================================================================
+/**
+ * Handle failed message delivery by adding to DLQ.
+ */
+export async function handleDeliveryFailure(dlq, envelope, reason, attemptCount, errorMessage) {
+    return dlq.add(envelope.id, {
+        from: envelope.from,
+        to: envelope.to,
+        topic: envelope.topic,
+        kind: envelope.payload.kind,
+        body: envelope.payload.body,
+        data: envelope.payload.data,
+        thread: envelope.payload.thread,
+        ts: envelope.ts,
+    }, reason, attemptCount, errorMessage);
+}
+/**
+ * Sign an outgoing envelope if signing is enabled.
+ */
+export function signEnvelope(signing, envelope, agentName) {
+    if (!signing.enabled) {
+        return envelope;
+    }
+    const content = JSON.stringify(envelope);
+    const signed = signing.sign(agentName, content);
+    if (!signed) {
+        return envelope;
+    }
+    return attachSignature(envelope, signed);
+}
+/**
+ * Verify an incoming envelope signature.
+ */
+export function verifyEnvelope(signing, envelope) {
+    if (!signing.enabled) {
+        return { valid: true };
+    }
+    const signed = extractSignature(envelope);
+    if (!signed) {
+        const from = typeof envelope.from === 'string' ? envelope.from : 'unknown';
+        if (signing.requiresVerification(from)) {
+            return { valid: false, error: 'Missing signature' };
+        }
+        return { valid: true };
+    }
+    return signing.verify(signed);
+}
+// =============================================================================
+// Consensus Integration Helpers
+// =============================================================================
+/**
+ * Process a potential vote command from a relay message.
+ */
+export function processVoteMessage(consensus, from, body) {
+    const vote = parseVoteCommand(body);
+    if (!vote) {
+        return { processed: false };
+    }
+    const result = consensus.vote(vote.proposalId, from, vote.value, vote.reason);
+    return { processed: true, result };
+}
+/**
+ * Create a proposal and format it for broadcast.
+ */
+export function createAndBroadcastProposal(consensus, options) {
+    const proposal = consensus.createProposal(options);
+    const message = formatProposalMessage(proposal);
+    return { proposal, message };
+}
+// =============================================================================
+// Context Management Helpers
+// =============================================================================
+/**
+ * Check if context needs compaction and compact if necessary.
+ */
+export function manageContext(compactor, messages) {
+    const budget = compactor.getTokenBudget(messages);
+    if (!compactor.needsCompaction(messages)) {
+        return { messages, compacted: false, budget };
+    }
+    const result = compactor.compact(messages);
+    return {
+        messages: result.messages,
+        compacted: true,
+        result,
+        budget: compactor.getTokenBudget(result.messages),
+    };
+}
+// =============================================================================
+// Re-exports for convenience
+// =============================================================================
+export { 
+// Patterns
+getCompiledPatterns, isInstructionalTextFast, isPlaceholderTargetFast, stripAnsiFast, StaticPatterns, 
+// Signing
+AgentSigningManager, loadSigningConfig, attachSignature, extractSignature, 
+// DLQ
+SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, 
+// Compaction
+ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, formatTokenCount, 
+// Consensus
+ConsensusEngine, createConsensusEngine, formatProposalMessage, parseVoteCommand, formatResultMessage, };
+//# sourceMappingURL=enhanced-features.js.map

package/dist/daemon/index.d.ts

@@ -7,4 +7,8 @@ export * from './types.js';
 export * from './orchestrator.js';
 export * from './workspace-manager.js';
 export * from './agent-manager.js';
+export * from './enhanced-features.js';
+export * from './agent-signing.js';
+export * from './consensus.js';
+export * from './consensus-integration.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/daemon/index.js

@@ -9,4 +9,9 @@ export * from './types.js';
 export * from './orchestrator.js';
 export * from './workspace-manager.js';
 export * from './agent-manager.js';
+// Enhanced features (performance, reliability, coordination)
+export * from './enhanced-features.js';
+export * from './agent-signing.js';
+export * from './consensus.js';
+export * from './consensus-integration.js';
 //# sourceMappingURL=index.js.map

package/dist/daemon/rate-limiter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Token bucket rate limiter for per-agent message throttling.
+ *
+ * Uses a token bucket algorithm that allows bursting while enforcing
+ * an average rate limit. Generous defaults to avoid blocking legitimate
+ * agent communication.
+ */
+export interface RateLimitConfig {
+    /** Messages allowed per second (sustained rate). Default: 500 */
+    messagesPerSecond: number;
+    /** Maximum burst size (tokens in bucket). Default: 1000 */
+    burstSize: number;
+    /** Whether to log rate limit events. Default: true */
+    logEvents: boolean;
+}
+export declare const DEFAULT_RATE_LIMIT_CONFIG: RateLimitConfig;
+export interface RateLimitResult {
+    allowed: boolean;
+    remainingTokens: number;
+    retryAfterMs?: number;
+}
+export declare class RateLimiter {
+    private buckets;
+    private config;
+    constructor(config?: Partial<RateLimitConfig>);
+    /**
+     * Try to acquire a token for the given agent.
+     * Returns true if the message should be allowed, false if rate limited.
+     */
+    tryAcquire(agentName: string): boolean;
+    /**
+     * Try to acquire a token with detailed result.
+     */
+    tryAcquireWithResult(agentName: string): RateLimitResult;
+    /**
+     * Get remaining tokens for an agent (for monitoring/debugging).
+     */
+    getRemainingTokens(agentName: string): number;
+    /**
+     * Reset rate limit for an agent (useful for testing or admin override).
+     */
+    reset(agentName: string): void;
+    /**
+     * Reset all rate limits.
+     */
+    resetAll(): void;
+    /**
+     * Get rate limiter statistics.
+     */
+    getStats(): {
+        agentCount: number;
+        config: RateLimitConfig;
+    };
+    /**
+     * Clean up stale buckets (agents that haven't sent messages in a while).
+     * Call periodically to prevent memory growth.
+     */
+    cleanup(maxAgeMs?: number): number;
+}
+/**
+ * No-op rate limiter for when rate limiting is disabled.
+ */
+export declare class NoOpRateLimiter extends RateLimiter {
+    constructor();
+    tryAcquire(_agentName: string): boolean;
+    tryAcquireWithResult(_agentName: string): RateLimitResult;
+}
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/daemon/rate-limiter.js

@@ -0,0 +1,130 @@
+/**
+ * Token bucket rate limiter for per-agent message throttling.
+ *
+ * Uses a token bucket algorithm that allows bursting while enforcing
+ * an average rate limit. Generous defaults to avoid blocking legitimate
+ * agent communication.
+ */
+export const DEFAULT_RATE_LIMIT_CONFIG = {
+    // Very generous defaults - 500/sec sustained, 1000 burst
+    // This allows agents to send in bursts without being throttled
+    messagesPerSecond: 500,
+    burstSize: 1000,
+    logEvents: true,
+};
+export class RateLimiter {
+    buckets = new Map();
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_RATE_LIMIT_CONFIG, ...config };
+    }
+    /**
+     * Try to acquire a token for the given agent.
+     * Returns true if the message should be allowed, false if rate limited.
+     */
+    tryAcquire(agentName) {
+        return this.tryAcquireWithResult(agentName).allowed;
+    }
+    /**
+     * Try to acquire a token with detailed result.
+     */
+    tryAcquireWithResult(agentName) {
+        const now = Date.now();
+        let bucket = this.buckets.get(agentName);
+        if (!bucket) {
+            // New agent - start with full bucket
+            bucket = {
+                tokens: this.config.burstSize,
+                lastRefill: now,
+            };
+            this.buckets.set(agentName, bucket);
+        }
+        // Refill tokens based on time elapsed
+        const elapsedMs = now - bucket.lastRefill;
+        const tokensToAdd = (elapsedMs / 1000) * this.config.messagesPerSecond;
+        bucket.tokens = Math.min(this.config.burstSize, bucket.tokens + tokensToAdd);
+        bucket.lastRefill = now;
+        if (bucket.tokens >= 1) {
+            bucket.tokens -= 1;
+            return {
+                allowed: true,
+                remainingTokens: Math.floor(bucket.tokens),
+            };
+        }
+        // Rate limited - calculate retry time
+        const tokensNeeded = 1 - bucket.tokens;
+        const retryAfterMs = Math.ceil((tokensNeeded / this.config.messagesPerSecond) * 1000);
+        if (this.config.logEvents) {
+            console.warn(`[rate-limiter] Agent ${agentName} rate limited, retry in ${retryAfterMs}ms`);
+        }
+        return {
+            allowed: false,
+            remainingTokens: 0,
+            retryAfterMs,
+        };
+    }
+    /**
+     * Get remaining tokens for an agent (for monitoring/debugging).
+     */
+    getRemainingTokens(agentName) {
+        const bucket = this.buckets.get(agentName);
+        if (!bucket)
+            return this.config.burstSize;
+        // Calculate current tokens with refill
+        const now = Date.now();
+        const elapsedMs = now - bucket.lastRefill;
+        const tokensToAdd = (elapsedMs / 1000) * this.config.messagesPerSecond;
+        return Math.min(this.config.burstSize, Math.floor(bucket.tokens + tokensToAdd));
+    }
+    /**
+     * Reset rate limit for an agent (useful for testing or admin override).
+     */
+    reset(agentName) {
+        this.buckets.delete(agentName);
+    }
+    /**
+     * Reset all rate limits.
+     */
+    resetAll() {
+        this.buckets.clear();
+    }
+    /**
+     * Get rate limiter statistics.
+     */
+    getStats() {
+        return {
+            agentCount: this.buckets.size,
+            config: this.config,
+        };
+    }
+    /**
+     * Clean up stale buckets (agents that haven't sent messages in a while).
+     * Call periodically to prevent memory growth.
+     */
+    cleanup(maxAgeMs = 60 * 60 * 1000) {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [agentName, bucket] of this.buckets) {
+            if (now - bucket.lastRefill > maxAgeMs) {
+                this.buckets.delete(agentName);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+}
+/**
+ * No-op rate limiter for when rate limiting is disabled.
+ */
+export class NoOpRateLimiter extends RateLimiter {
+    constructor() {
+        super({ messagesPerSecond: Infinity, burstSize: Infinity, logEvents: false });
+    }
+    tryAcquire(_agentName) {
+        return true;
+    }
+    tryAcquireWithResult(_agentName) {
+        return { allowed: true, remainingTokens: Infinity };
+    }
+}
+//# sourceMappingURL=rate-limiter.js.map