agent-relay 1.3.1 → 1.3.3

package/dist/daemon/connection.js

@@ -7,14 +7,12 @@
  *                     v            v
  *                   ERROR -------> CLOSED
  */
-import { v4 as uuid } from 'uuid';
+import { generateId } from '../utils/id-generator.js';
 import { PROTOCOL_VERSION, } from '../protocol/types.js';
-import { encodeFrame, FrameParser } from '../protocol/framing.js';
+import { encodeFrameLegacy as encodeFrame, FrameParser } from '../protocol/framing.js';
+import { DEFAULT_CONNECTION_CONFIG } from '../config/relay-config.js';
 export const DEFAULT_CONFIG = {
-    maxFrameBytes: 1024 * 1024,
-    heartbeatMs: 5000,
-    // 6x multiplier = 30 second timeout, more tolerant for AI agents processing long responses
-    heartbeatTimeoutMultiplier: 6,
+    ...DEFAULT_CONNECTION_CONFIG,
 };
 export class Connection {
     id;
@@ -38,6 +36,11 @@ export class Connection {
     lastPongReceived;
     // Sequence numbers per (topic, peer) stream
     sequences = new Map();
+    // Write queue for backpressure handling
+    writeQueue = [];
+    draining = false;
+    _backpressured = false;
+    socketDrainHandler;
     // Event handlers
     onMessage;
     onClose;
@@ -45,13 +48,16 @@ export class Connection {
     onActive; // Fires when connection transitions to ACTIVE state
     onAck;
     onPong; // Fires on successful heartbeat response
+    /** Fires when write queue crosses high/low water marks */
+    onBackpressure;
     constructor(socket, config = {}) {
-        this.id = uuid();
+        this.id = generateId();
         this.socket = socket;
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.parser = new FrameParser(this.config.maxFrameBytes);
-        this._sessionId = uuid();
-        this._resumeToken = uuid();
+        this.parser.setLegacyMode(true); // Use 4-byte header for backwards compatibility
+        this._sessionId = generateId();
+        this._resumeToken = generateId();
         this.setupSocketHandlers();
         this._state = 'HANDSHAKING';
     }
@@ -94,6 +100,14 @@ export class Connection {
     get isResumed() {
         return this._isResumed;
     }
+    /** Whether this connection is currently backpressured (write queue above high water mark) */
+    get backpressured() {
+        return this._backpressured;
+    }
+    /** Current number of messages queued for writing */
+    get writeQueueLength() {
+        return this.writeQueue.length;
+    }
     setupSocketHandlers() {
         this.socket.on('data', (data) => this.handleData(data));
         this.socket.on('close', () => this.handleClose());
@@ -187,7 +201,7 @@ export class Connection {
         const welcome = {
             v: PROTOCOL_VERSION,
             type: 'WELCOME',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 session_id: this._sessionId,
@@ -244,11 +258,11 @@ export class Connection {
                 }
             }
             // Send ping
-            const nonce = uuid();
+            const nonce = generateId();
             this.send({
                 v: PROTOCOL_VERSION,
                 type: 'PING',
-                id: uuid(),
+                id: generateId(),
                 ts: now,
                 payload: { nonce },
             });
@@ -281,14 +295,33 @@ export class Connection {
     }
     /**
      * Send an envelope to this connection.
+     *
+     * Uses a write queue to prevent blocking on slow consumers.
+     * Returns false if the connection is closed or the queue is full.
      */
     send(envelope) {
-        if (this._state === 'CLOSED' || this._state === 'ERROR') {
+        if (this._state === 'CLOSED' || this._state === 'ERROR' || this._state === 'CLOSING') {
+            console.log(`[connection] Send to ${this._agentName} blocked - state: ${this._state}`);
+            return false;
+        }
+        const maxQueueSize = this.config.maxWriteQueueSize ?? 2000;
+        const highWaterMark = this.config.writeQueueHighWaterMark ?? 1500;
+        // Check queue capacity
+        if (this.writeQueue.length >= maxQueueSize) {
+            // Queue full - this is a serious condition, log it
+            console.warn(`[connection] Write queue full for ${this._agentName ?? this.id}, dropping message`);
             return false;
         }
         try {
             const frame = encodeFrame(envelope);
-            this.socket.write(frame);
+            this.writeQueue.push(frame);
+            // Check if we should signal backpressure
+            if (!this._backpressured && this.writeQueue.length >= highWaterMark) {
+                this._backpressured = true;
+                this.onBackpressure?.(true);
+            }
+            // Schedule drain if not already draining
+            this.scheduleDrain();
             return true;
         }
         catch (err) {
@@ -296,11 +329,53 @@ export class Connection {
             return false;
         }
     }
+    /**
+     * Schedule the drain loop to run on next tick if not already running.
+     */
+    scheduleDrain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        setImmediate(() => this.drain());
+    }
+    /**
+     * Drain the write queue to the socket.
+     * Respects socket backpressure by waiting for 'drain' events.
+     */
+    drain() {
+        while (this.writeQueue.length > 0) {
+            if (this._state === 'CLOSED' || this._state === 'ERROR' || this._state === 'CLOSING') {
+                this.draining = false;
+                return;
+            }
+            const frame = this.writeQueue[0];
+            const canWrite = this.socket.write(frame);
+            this.writeQueue.shift();
+            if (!canWrite) {
+                // Socket buffer full - wait for drain event
+                if (!this.socketDrainHandler) {
+                    this.socketDrainHandler = () => {
+                        this.socketDrainHandler = undefined;
+                        this.drain();
+                    };
+                    this.socket.once('drain', this.socketDrainHandler);
+                }
+                return;
+            }
+        }
+        this.draining = false;
+        // Check if we should release backpressure
+        const lowWaterMark = this.config.writeQueueLowWaterMark ?? 500;
+        if (this._backpressured && this.writeQueue.length <= lowWaterMark) {
+            this._backpressured = false;
+            this.onBackpressure?.(false);
+        }
+    }
     sendError(code, message, fatal) {
         const error = {
             v: PROTOCOL_VERSION,
             type: 'ERROR',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 code: code,
@@ -329,18 +404,34 @@ export class Connection {
     }
     cleanup() {
         this.parser.reset();
+        // Clear write queue
+        this.writeQueue = [];
+        this.draining = false;
+        this._backpressured = false;
+        // Remove drain handler if registered
+        if (this.socketDrainHandler) {
+            this.socket.removeListener('drain', this.socketDrainHandler);
+            this.socketDrainHandler = undefined;
+        }
     }
     close() {
         if (this._state === 'CLOSED' || this._state === 'CLOSING')
             return;
         this._state = 'CLOSING';
-        this.send({
-            v: PROTOCOL_VERSION,
-            type: 'BYE',
-            id: uuid(),
-            ts: Date.now(),
-            payload: {},
-        });
+        // Write BYE message directly (not via queue) to avoid race with socket.end()
+        try {
+            const byeFrame = encodeFrame({
+                v: PROTOCOL_VERSION,
+                type: 'BYE',
+                id: generateId(),
+                ts: Date.now(),
+                payload: {},
+            });
+            this.socket.write(byeFrame);
+        }
+        catch {
+            // Ignore write errors during close
+        }
         this.socket.end();
     }
 }

package/dist/daemon/consensus-integration.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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 { ConsensusEngine, createConsensusEngine, formatProposalMessage, formatResultMessage, parseVoteCommand, parseProposalCommand, isConsensusCommand, type Proposal, type ConsensusResult, type ConsensusConfig, type VoteValue, type ConsensusType, type ParsedProposalCommand } from './consensus.js';
+import type { Router } from './router.js';
+export interface CloudSyncConfig {
+    /** Cloud API base URL (defaults to AGENT_RELAY_CLOUD_URL or https://agent-relay.com) */
+    url?: string;
+    /** Daemon API key for authentication (defaults to AGENT_RELAY_API_KEY) */
+    apiKey?: string;
+    /** Workspace ID for self-hosted setups (optional - cloud can derive from API key) */
+    workspaceId?: string;
+}
+export interface ConsensusIntegrationConfig {
+    /** Enable consensus feature (default: true) */
+    enabled: boolean;
+    /** Consensus engine configuration */
+    consensus?: Partial<ConsensusConfig>;
+    /** Auto-broadcast proposals to participants (default: true) */
+    autoBroadcast?: boolean;
+    /** Auto-broadcast results when resolved (default: true) */
+    autoResultBroadcast?: boolean;
+    /** Log consensus events (default: true) */
+    logEvents?: boolean;
+    /** Cloud sync configuration (optional) */
+    cloudSync?: CloudSyncConfig;
+}
+export interface ProposalOptions {
+    title: string;
+    description: string;
+    proposer: string;
+    participants: string[];
+    consensusType?: ConsensusType;
+    timeoutMs?: number;
+    quorum?: number;
+    threshold?: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Integrates consensus mechanism with the relay router.
+ * Provides automatic proposal broadcasting and vote detection.
+ */
+export declare class ConsensusIntegration {
+    private config;
+    private engine;
+    private router;
+    private log;
+    constructor(router: Router, config?: Partial<ConsensusIntegrationConfig>);
+    /**
+     * Check if consensus is enabled.
+     */
+    get enabled(): boolean;
+    /**
+     * Get the underlying consensus engine.
+     */
+    getEngine(): ConsensusEngine;
+    /**
+     * Create a new proposal and optionally broadcast to participants.
+     */
+    createProposal(options: ProposalOptions): Proposal;
+    /**
+     * Process an incoming message to detect and handle consensus commands.
+     * Handles both PROPOSE and VOTE commands.
+     */
+    processIncomingMessage(from: string, body: string): {
+        isConsensusCommand: boolean;
+        type?: 'propose' | 'vote';
+        result?: {
+            success: boolean;
+            error?: string;
+            proposal?: Proposal;
+        };
+    };
+    /**
+     * Check if a message is a consensus command without processing it.
+     */
+    isConsensusMessage(body: string): boolean;
+    /**
+     * Get pending proposals for an agent.
+     */
+    getPendingVotes(agentName: string): Proposal[];
+    /**
+     * Get all proposals for an agent.
+     */
+    getProposals(agentName: string): Proposal[];
+    /**
+     * Get a specific proposal by ID.
+     */
+    getProposal(proposalId: string): Proposal | null;
+    /**
+     * Cancel a proposal.
+     */
+    cancelProposal(proposalId: string, agentName: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Get consensus statistics.
+     */
+    getStats(): {
+        total: number;
+        pending: number;
+        approved: number;
+        rejected: number;
+        expired: number;
+        cancelled: number;
+        avgParticipation: number;
+    };
+    /**
+     * Cleanup resources.
+     */
+    cleanup(): void;
+    /**
+     * 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
+     */
+    private syncToCloud;
+    private setupEventHandlers;
+    /**
+     * Broadcast a proposal to all participants via the router.
+     */
+    private broadcastProposal;
+    /**
+     * Broadcast the result of a proposal to all participants.
+     */
+    private broadcastResult;
+    /**
+     * Send a message to an agent via the router.
+     */
+    private sendToAgent;
+}
+/**
+ * Create a consensus integration instance.
+ */
+export declare function createConsensusIntegration(router: Router, config?: Partial<ConsensusIntegrationConfig>): ConsensusIntegration;
+export { ConsensusEngine, createConsensusEngine, formatProposalMessage, formatResultMessage, parseVoteCommand, parseProposalCommand, isConsensusCommand, type Proposal, type ConsensusResult, type ConsensusConfig, type VoteValue, type ConsensusType, type ParsedProposalCommand, };
+//# sourceMappingURL=consensus-integration.d.ts.map