agent-relay 1.6.0 → 2.0.0

package/packages/daemon/dist/consensus-integration.js

@@ -0,0 +1,371 @@
+/**
+ * Consensus Integration for Agent Relay
+ *
+ * Integrates the consensus mechanism with the router/daemon.
+ * This is an optional feature that can be enabled to allow agents
+ * to participate in distributed decision-making.
+ *
+ * Usage:
+ * 1. Create a ConsensusIntegration with the router and optional config
+ * 2. Call processIncomingMessage() on each received message to detect votes
+ * 3. Use createProposal() to start a new consensus vote
+ *
+ * Example:
+ * ```typescript
+ * const consensus = new ConsensusIntegration(router, { enabled: true });
+ *
+ * // Create a proposal
+ * consensus.createProposal({
+ *   title: 'Approve API design',
+ *   description: 'Should we proceed with the REST API design?',
+ *   proposer: 'Architect',
+ *   participants: ['Developer', 'Reviewer', 'Lead'],
+ *   consensusType: 'majority',
+ * });
+ *
+ * // Process incoming messages to detect votes
+ * consensus.processIncomingMessage(from, body);
+ * ```
+ */
+import { generateId } from '@agent-relay/wrapper';
+import { ConsensusEngine, createConsensusEngine, formatProposalMessage, formatResultMessage, parseVoteCommand, parseProposalCommand, isConsensusCommand, } from './consensus.js';
+import { PROTOCOL_VERSION } from '@agent-relay/protocol/types';
+const DEFAULT_CONFIG = {
+    enabled: true,
+    autoBroadcast: true,
+    autoResultBroadcast: true,
+    logEvents: true,
+};
+// =============================================================================
+// Consensus Integration
+// =============================================================================
+/**
+ * Integrates consensus mechanism with the relay router.
+ * Provides automatic proposal broadcasting and vote detection.
+ */
+export class ConsensusIntegration {
+    config;
+    engine;
+    router;
+    log;
+    constructor(router, config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.router = router;
+        this.engine = createConsensusEngine(config.consensus);
+        // Setup logging
+        this.log = this.config.logEvents
+            ? (msg, data) => console.log(`[consensus] ${msg}`, data ?? '')
+            : () => { };
+        // Subscribe to engine events
+        this.setupEventHandlers();
+    }
+    /**
+     * Check if consensus is enabled.
+     */
+    get enabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get the underlying consensus engine.
+     */
+    getEngine() {
+        return this.engine;
+    }
+    /**
+     * Create a new proposal and optionally broadcast to participants.
+     */
+    createProposal(options) {
+        if (!this.config.enabled) {
+            throw new Error('Consensus is not enabled');
+        }
+        const proposal = this.engine.createProposal({
+            ...options,
+            thread: `consensus-${options.title.toLowerCase().replace(/\s+/g, '-')}`,
+        });
+        this.log('Proposal created', { id: proposal.id, title: proposal.title });
+        return proposal;
+    }
+    /**
+     * Process an incoming message to detect and handle consensus commands.
+     * Handles both PROPOSE and VOTE commands.
+     */
+    processIncomingMessage(from, body) {
+        if (!this.config.enabled) {
+            return { isConsensusCommand: false };
+        }
+        // Check for PROPOSE command
+        const proposeCmd = parseProposalCommand(body);
+        if (proposeCmd) {
+            try {
+                const proposal = this.createProposal({
+                    ...proposeCmd,
+                    proposer: from,
+                });
+                this.log('Proposal created via command', {
+                    from,
+                    proposalId: proposal.id,
+                    title: proposal.title,
+                });
+                return {
+                    isConsensusCommand: true,
+                    type: 'propose',
+                    result: { success: true, proposal },
+                };
+            }
+            catch (err) {
+                return {
+                    isConsensusCommand: true,
+                    type: 'propose',
+                    result: {
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Failed to create proposal',
+                    },
+                };
+            }
+        }
+        // Check for VOTE command
+        const voteCmd = parseVoteCommand(body);
+        if (voteCmd) {
+            const result = this.engine.vote(voteCmd.proposalId, from, voteCmd.value, voteCmd.reason);
+            this.log('Vote received', {
+                from,
+                proposalId: voteCmd.proposalId,
+                value: voteCmd.value,
+                success: result.success,
+            });
+            return { isConsensusCommand: true, type: 'vote', result };
+        }
+        return { isConsensusCommand: false };
+    }
+    /**
+     * Check if a message is a consensus command without processing it.
+     */
+    isConsensusMessage(body) {
+        return isConsensusCommand(body);
+    }
+    /**
+     * Get pending proposals for an agent.
+     */
+    getPendingVotes(agentName) {
+        return this.engine.getPendingVotesForAgent(agentName);
+    }
+    /**
+     * Get all proposals for an agent.
+     */
+    getProposals(agentName) {
+        return this.engine.getProposalsForAgent(agentName);
+    }
+    /**
+     * Get a specific proposal by ID.
+     */
+    getProposal(proposalId) {
+        return this.engine.getProposal(proposalId);
+    }
+    /**
+     * Cancel a proposal.
+     */
+    cancelProposal(proposalId, agentName) {
+        return this.engine.cancelProposal(proposalId, agentName);
+    }
+    /**
+     * Get consensus statistics.
+     */
+    getStats() {
+        return this.engine.getStats();
+    }
+    /**
+     * Cleanup resources.
+     */
+    cleanup() {
+        this.engine.cleanup();
+    }
+    // ===========================================================================
+    // Private Methods
+    // ===========================================================================
+    /**
+     * Sync a proposal to the cloud dashboard.
+     *
+     * Auto-detects cloud settings from workspace env vars:
+     * - CLOUD_API_URL / AGENT_RELAY_CLOUD_URL - cloud URL
+     * - WORKSPACE_ID / AGENT_RELAY_WORKSPACE_ID - workspace ID
+     * - WORKSPACE_TOKEN / AGENT_RELAY_API_KEY - auth token
+     */
+    async syncToCloud(proposal, event) {
+        // Get cloud sync settings - check workspace env vars first, then agent-relay vars
+        const cloudUrl = this.config.cloudSync?.url
+            || process.env.CLOUD_API_URL
+            || process.env.AGENT_RELAY_CLOUD_URL;
+        const workspaceId = this.config.cloudSync?.workspaceId
+            || process.env.WORKSPACE_ID
+            || process.env.AGENT_RELAY_WORKSPACE_ID;
+        const token = this.config.cloudSync?.apiKey
+            || process.env.WORKSPACE_TOKEN
+            || process.env.AGENT_RELAY_API_KEY;
+        // Skip if no cloud URL configured
+        if (!cloudUrl) {
+            return;
+        }
+        // Skip if no workspace ID
+        if (!workspaceId) {
+            return;
+        }
+        try {
+            const url = `${cloudUrl}/api/daemons/consensus/sync`;
+            // Build headers - token is optional for localhost
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ proposal, event, workspaceId }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.log(`Cloud sync failed: ${response.status} ${errorText}`);
+            }
+            else {
+                this.log(`Cloud sync: ${event} for proposal ${proposal.id}`);
+            }
+        }
+        catch (err) {
+            // Don't fail on cloud sync errors - just log them
+            this.log(`Cloud sync error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    setupEventHandlers() {
+        // Broadcast new proposals to participants
+        this.engine.on('proposal:created', (proposal) => {
+            if (this.config.autoBroadcast) {
+                this.broadcastProposal(proposal);
+            }
+            // Sync to cloud dashboard
+            this.syncToCloud(proposal, 'created');
+        });
+        // Notify participants when someone votes
+        this.engine.on('proposal:voted', (proposal, vote) => {
+            this.log('Vote recorded', {
+                proposalId: proposal.id,
+                voter: vote.agent,
+                value: vote.value,
+            });
+            // Sync updated proposal to cloud dashboard
+            this.syncToCloud(proposal, 'voted');
+        });
+        // Broadcast results when resolved
+        this.engine.on('proposal:resolved', (proposal, result) => {
+            this.log('Proposal resolved', {
+                id: proposal.id,
+                decision: result.decision,
+                participation: `${(result.participation * 100).toFixed(1)}%`,
+            });
+            if (this.config.autoResultBroadcast) {
+                this.broadcastResult(proposal, result);
+            }
+            // Sync resolved proposal to cloud dashboard
+            this.syncToCloud(proposal, 'resolved');
+        });
+        // Log expired proposals
+        this.engine.on('proposal:expired', (proposal) => {
+            this.log('Proposal expired', { id: proposal.id, title: proposal.title });
+            // Sync expired proposal to cloud dashboard
+            this.syncToCloud(proposal, 'expired');
+        });
+        // Log cancelled proposals
+        this.engine.on('proposal:cancelled', (proposal) => {
+            this.log('Proposal cancelled', { id: proposal.id, title: proposal.title });
+            // Sync cancelled proposal to cloud dashboard
+            this.syncToCloud(proposal, 'cancelled');
+        });
+    }
+    /**
+     * Broadcast a proposal to all participants via the router.
+     */
+    broadcastProposal(proposal) {
+        const message = formatProposalMessage(proposal);
+        for (const participant of proposal.participants) {
+            this.sendToAgent(proposal.proposer, participant, message, proposal.thread);
+        }
+        this.log('Proposal broadcast', {
+            id: proposal.id,
+            recipients: proposal.participants.length,
+        });
+    }
+    /**
+     * Broadcast the result of a proposal to all participants.
+     */
+    broadcastResult(proposal, result) {
+        const message = formatResultMessage(proposal, result);
+        // Send to proposer
+        this.sendToAgent('_consensus', proposal.proposer, message, proposal.thread);
+        // Send to all participants
+        for (const participant of proposal.participants) {
+            if (participant !== proposal.proposer) {
+                this.sendToAgent('_consensus', participant, message, proposal.thread);
+            }
+        }
+        this.log('Result broadcast', {
+            id: proposal.id,
+            decision: result.decision,
+            recipients: proposal.participants.length,
+        });
+    }
+    /**
+     * Send a message to an agent via the router.
+     */
+    sendToAgent(from, to, body, thread) {
+        // Create a SEND envelope
+        const envelope = {
+            v: PROTOCOL_VERSION,
+            type: 'SEND',
+            id: generateId(),
+            ts: Date.now(),
+            from,
+            to,
+            payload: {
+                kind: 'action',
+                body,
+                thread,
+                data: {
+                    _isConsensusMessage: true,
+                    _consensusAction: 'proposal',
+                },
+            },
+        };
+        // Get the target connection and route
+        const target = this.router.getConnection(to);
+        if (target) {
+            // Use a mock connection for system messages
+            const mockFrom = {
+                id: `consensus-${generateId()}`,
+                agentName: from,
+                sessionId: 'consensus-system',
+                close: () => { },
+                send: () => true,
+                getNextSeq: () => 0,
+            };
+            // Route the message
+            this.router.route(mockFrom, envelope);
+        }
+        else {
+            this.log(`Target agent not connected: ${to}`);
+        }
+    }
+}
+// =============================================================================
+// Factory Function
+// =============================================================================
+/**
+ * Create a consensus integration instance.
+ */
+export function createConsensusIntegration(router, config) {
+    return new ConsensusIntegration(router, config);
+}
+// =============================================================================
+// Re-exports for convenience
+// =============================================================================
+export { ConsensusEngine, createConsensusEngine, formatProposalMessage, formatResultMessage, parseVoteCommand, parseProposalCommand, isConsensusCommand, };
+//# sourceMappingURL=consensus-integration.js.map

package/packages/daemon/dist/delivery-tracker.d.ts

@@ -0,0 +1,34 @@
+import type { DeliverEnvelope, AckPayload, Envelope } from '@agent-relay/protocol/types';
+import type { StorageAdapter } from '@agent-relay/storage/adapter';
+export interface DeliveryReliabilityOptions {
+    /** How long to wait for an ACK before retrying (ms) */
+    ackTimeoutMs: number;
+    /** Maximum attempts (initial send counts as attempt 1) */
+    maxAttempts: number;
+    /** How long to keep retrying before dropping (ms) */
+    deliveryTtlMs: number;
+}
+export declare const DEFAULT_DELIVERY_OPTIONS: DeliveryReliabilityOptions;
+export interface DeliveryTrackerConnection {
+    id: string;
+    send(envelope: DeliverEnvelope): boolean;
+}
+export declare class DeliveryTracker {
+    private pendingDeliveries;
+    private deliveryOptions;
+    private storage?;
+    private getConnection;
+    constructor(options: {
+        storage?: StorageAdapter;
+        delivery?: Partial<DeliveryReliabilityOptions>;
+        getConnection: (id: string) => DeliveryTrackerConnection | undefined;
+    });
+    get pendingCount(): number;
+    track(target: DeliveryTrackerConnection, deliver: DeliverEnvelope): void;
+    handleAck(connectionId: string, ackId: string): void;
+    clearPendingForConnection(connectionId: string): void;
+    private scheduleRetry;
+    private markFailed;
+}
+export type AckEnvelope = Envelope<AckPayload>;
+//# sourceMappingURL=delivery-tracker.d.ts.map

package/packages/daemon/dist/delivery-tracker.js

@@ -0,0 +1,104 @@
+import { routerLog } from '@agent-relay/utils/logger';
+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/packages/daemon/dist/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 '@agent-relay/utils/precompiled-patterns';
+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 '@agent-relay/storage/dlq-adapter';
+import { ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, formatTokenCount, type Message, type CompactionConfig, type CompactionResult } from '@agent-relay/memory';
+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 { 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