@kadi.build/core 0.0.1-alpha.1 → 0.0.1-alpha.11

package/dist/broker/BrokerConnection.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Broker Connection
+ *
+ * Wraps a single WebSocket connection to a KADI broker.
+ * Handles connection lifecycle, message sending/receiving, and state management.
+ *
+ * @module broker/BrokerConnection
+ */
+import { EventEmitter } from 'events';
+import type { BrokerConfig, JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from '../types/index.js';
+import { ConnectionState } from '../types/index.js';
+/**
+ * Broker Connection Events
+ */
+export interface BrokerConnectionEvents {
+    /**
+     * Emitted when connection is established
+     */
+    connected: () => void;
+    /**
+     * Emitted when connection is closed
+     */
+    disconnected: (code: number, reason: string) => void;
+    /**
+     * Emitted when an error occurs
+     */
+    error: (error: Error) => void;
+    /**
+     * Emitted when a message is received
+     */
+    message: (message: JsonRpcResponse | JsonRpcNotification) => void;
+    /**
+     * Emitted when connection state changes
+     */
+    stateChange: (oldState: ConnectionState, newState: ConnectionState) => void;
+}
+/**
+ * Broker Connection
+ *
+ * Manages a single WebSocket connection to a broker.
+ * Handles low-level connection lifecycle and message framing.
+ *
+ * Does NOT handle:
+ * - Protocol logic (handshake, auth) - that's BrokerProtocol's job
+ * - Multiple connections - that's BrokerConnectionManager's job
+ *
+ * @example
+ * ```typescript
+ * const connection = new BrokerConnection({
+ *   url: 'ws://localhost:8080',
+ *   name: 'local',
+ *   connectionTimeout: 10000
+ * });
+ *
+ * connection.on('connected', () => {
+ *   console.log('Connected to broker');
+ * });
+ *
+ * connection.on('message', (message) => {
+ *   console.log('Received:', message);
+ * });
+ *
+ * await connection.connect();
+ * ```
+ */
+export declare class BrokerConnection extends EventEmitter {
+    /**
+     * Broker configuration
+     */
+    private readonly config;
+    /**
+     * WebSocket instance
+     */
+    private ws;
+    /**
+     * Current connection state
+     */
+    private _state;
+    /**
+     * Assigned agent ID (set after handshake)
+     */
+    private _agentId;
+    /**
+     * Heartbeat timer
+     */
+    private heartbeatTimer;
+    /**
+     * Connection timestamp
+     */
+    private _connectedAt;
+    /**
+     * Last heartbeat timestamp
+     */
+    private _lastHeartbeat;
+    /**
+     * Pending requests (for matching responses)
+     */
+    private pendingRequests;
+    /**
+     * Request ID counter
+     */
+    private requestIdCounter;
+    /**
+     * Create a new BrokerConnection
+     *
+     * @param config - Broker configuration
+     */
+    constructor(config: BrokerConfig);
+    /**
+     * Connect to the broker
+     *
+     * @throws {KadiError} If connection fails
+     *
+     * @example
+     * ```typescript
+     * await connection.connect();
+     * console.log('Connected!');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the broker
+     *
+     * @example
+     * ```typescript
+     * await connection.disconnect();
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC request and wait for response
+     *
+     * @template T - Response result type
+     * @param request - JSON-RPC request
+     * @returns Promise resolving to the response result
+     *
+     * @throws {KadiError} If request fails or times out
+     *
+     * @example
+     * ```typescript
+     * const result = await connection.sendRequest({
+     *   jsonrpc: '2.0',
+     *   method: 'kadi.handshake',
+     *   params: { name: 'my-agent' },
+     *   id: 1
+     * });
+     * ```
+     */
+    sendRequest<T = unknown>(request: JsonRpcRequest): Promise<T>;
+    /**
+     * Send a JSON-RPC notification (no response expected)
+     *
+     * @param notification - JSON-RPC notification
+     *
+     * @example
+     * ```typescript
+     * connection.sendNotification({
+     *   jsonrpc: '2.0',
+     *   method: 'kadi.heartbeat',
+     *   params: { timestamp: Date.now() }
+     * });
+     * ```
+     */
+    sendNotification(notification: JsonRpcNotification): void;
+    /**
+     * Send a tool result back to broker as JSON-RPC response
+     *
+     * Used when this client acts as a tool provider and needs to respond to invocations.
+     * The requestId must match the incoming request's id field for proper routing.
+     *
+     * @param requestId - Request ID to respond to (CRITICAL: must match incoming request id)
+     * @param result - Result data to send back
+     */
+    sendResponse(requestId: string | number | undefined, result: unknown): void;
+    /**
+     * Send a tool error back to broker as JSON-RPC error response
+     *
+     * Used when tool execution fails and we need to report the error back.
+     * The requestId must match the incoming request's id field for proper routing.
+     *
+     * @param requestId - Request ID to respond to (CRITICAL: must match incoming request id)
+     * @param code - Error code (e.g., ErrorCode.TOOL_NOT_FOUND)
+     * @param message - Human-readable error message
+     * @param data - Optional additional error context
+     */
+    sendError(requestId: string | number | undefined, code: string, message: string, data?: Record<string, unknown>): void;
+    /**
+     * Send raw data to broker
+     *
+     * @param data - Data to send (request, response, or notification)
+     */
+    private send;
+    /**
+     * Handle incoming WebSocket message
+     *
+     * @param data - Raw message data
+     */
+    private handleMessage;
+    /**
+     * Handle WebSocket close event
+     *
+     * @param code - Close code
+     * @param reason - Close reason
+     */
+    private handleClose;
+    /**
+     * Setup heartbeat timer
+     */
+    private setupHeartbeat;
+    /**
+     * Cleanup connection resources
+     */
+    private cleanup;
+    /**
+     * Set connection state and emit event
+     *
+     * @param newState - New state
+     */
+    private setState;
+    /**
+     * Get broker name
+     */
+    get name(): string;
+    /**
+     * Get broker URL
+     */
+    get url(): string;
+    /**
+     * Get current connection state
+     */
+    get state(): ConnectionState;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Get assigned agent ID
+     */
+    get agentId(): string | null;
+    /**
+     * Set agent ID (called after handshake)
+     */
+    set agentId(id: string | null);
+    /**
+     * Get connection timestamp
+     */
+    get connectedAt(): number | null;
+    /**
+     * Get last heartbeat timestamp
+     */
+    get lastHeartbeat(): number | null;
+}
+//# sourceMappingURL=BrokerConnection.d.ts.map

package/dist/broker/BrokerConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrokerConnection.d.ts","sourceRoot":"","sources":["../../src/broker/BrokerConnection.ts"],"names":[],"mappings":"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"}

package/dist/broker/BrokerConnection.js

@@ -0,0 +1,434 @@
+/**
+ * Broker Connection
+ *
+ * Wraps a single WebSocket connection to a KADI broker.
+ * Handles connection lifecycle, message sending/receiving, and state management.
+ *
+ * @module broker/BrokerConnection
+ */
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import { ConnectionState } from '../types/index.js';
+import { KadiError, ErrorCode } from '../types/index.js';
+/**
+ * Broker Connection
+ *
+ * Manages a single WebSocket connection to a broker.
+ * Handles low-level connection lifecycle and message framing.
+ *
+ * Does NOT handle:
+ * - Protocol logic (handshake, auth) - that's BrokerProtocol's job
+ * - Multiple connections - that's BrokerConnectionManager's job
+ *
+ * @example
+ * ```typescript
+ * const connection = new BrokerConnection({
+ *   url: 'ws://localhost:8080',
+ *   name: 'local',
+ *   connectionTimeout: 10000
+ * });
+ *
+ * connection.on('connected', () => {
+ *   console.log('Connected to broker');
+ * });
+ *
+ * connection.on('message', (message) => {
+ *   console.log('Received:', message);
+ * });
+ *
+ * await connection.connect();
+ * ```
+ */
+export class BrokerConnection extends EventEmitter {
+    /**
+     * Broker configuration
+     */
+    config;
+    /**
+     * WebSocket instance
+     */
+    ws = null;
+    /**
+     * Current connection state
+     */
+    _state = ConnectionState.DISCONNECTED;
+    /**
+     * Assigned agent ID (set after handshake)
+     */
+    _agentId = null;
+    /**
+     * Heartbeat timer
+     */
+    heartbeatTimer = null;
+    /**
+     * Connection timestamp
+     */
+    _connectedAt = null;
+    /**
+     * Last heartbeat timestamp
+     */
+    _lastHeartbeat = null;
+    /**
+     * Pending requests (for matching responses)
+     */
+    pendingRequests = new Map();
+    /**
+     * Request ID counter
+     */
+    requestIdCounter = 0;
+    /**
+     * Create a new BrokerConnection
+     *
+     * @param config - Broker configuration
+     */
+    constructor(config) {
+        super();
+        this.config = {
+            ...config,
+            connectionTimeout: config.connectionTimeout ?? 10000,
+            requestTimeout: config.requestTimeout ?? 30000,
+            heartbeatInterval: config.heartbeatInterval ?? 30000,
+            autoReconnect: config.autoReconnect ?? true,
+            maxReconnectAttempts: config.maxReconnectAttempts ?? 5
+        };
+    }
+    /**
+     * Connect to the broker
+     *
+     * @throws {KadiError} If connection fails
+     *
+     * @example
+     * ```typescript
+     * await connection.connect();
+     * console.log('Connected!');
+     * ```
+     */
+    async connect() {
+        if (this._state !== ConnectionState.DISCONNECTED) {
+            throw new KadiError('Connection already in progress or established', ErrorCode.CONNECTION_FAILED, 400, { currentState: this._state, broker: this.config.name });
+        }
+        this.setState(ConnectionState.CONNECTING);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.cleanup();
+                reject(new KadiError(`Connection timeout after ${this.config.connectionTimeout}ms`, ErrorCode.CONNECTION_TIMEOUT, 408, { broker: this.config.name, url: this.config.url }));
+            }, this.config.connectionTimeout);
+            try {
+                this.ws = new WebSocket(this.config.url);
+                this.ws.on('open', () => {
+                    clearTimeout(timeout);
+                    this._connectedAt = Date.now();
+                    this.setState(ConnectionState.CONNECTED);
+                    this.setupHeartbeat();
+                    this.emit('connected');
+                    resolve();
+                });
+                this.ws.on('error', (error) => {
+                    clearTimeout(timeout);
+                    this.emit('error', error);
+                    reject(new KadiError(`WebSocket error: ${error.message}`, ErrorCode.CONNECTION_FAILED, 500, { broker: this.config.name, url: this.config.url, originalError: error.message }));
+                });
+                this.ws.on('close', (code, reason) => {
+                    clearTimeout(timeout);
+                    this.handleClose(code, reason.toString());
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data);
+                });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                this.cleanup();
+                reject(KadiError.from(error, ErrorCode.CONNECTION_FAILED));
+            }
+        });
+    }
+    /**
+     * Disconnect from the broker
+     *
+     * @example
+     * ```typescript
+     * await connection.disconnect();
+     * ```
+     */
+    async disconnect() {
+        this.cleanup();
+    }
+    /**
+     * Send a JSON-RPC request and wait for response
+     *
+     * @template T - Response result type
+     * @param request - JSON-RPC request
+     * @returns Promise resolving to the response result
+     *
+     * @throws {KadiError} If request fails or times out
+     *
+     * @example
+     * ```typescript
+     * const result = await connection.sendRequest({
+     *   jsonrpc: '2.0',
+     *   method: 'kadi.handshake',
+     *   params: { name: 'my-agent' },
+     *   id: 1
+     * });
+     * ```
+     */
+    async sendRequest(request) {
+        if (!this.isConnected) {
+            throw new KadiError('Not connected to broker', ErrorCode.BROKER_NOT_CONNECTED, 503, { broker: this.config.name });
+        }
+        // Generate ID if not provided
+        if (request.id === undefined) {
+            request.id = ++this.requestIdCounter;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(request.id);
+                reject(new KadiError(`Request timeout after ${this.config.requestTimeout}ms`, ErrorCode.BROKER_TIMEOUT, 408, { broker: this.config.name, method: request.method, requestId: request.id }));
+            }, this.config.requestTimeout);
+            this.pendingRequests.set(request.id, {
+                id: request.id,
+                resolve: resolve,
+                reject,
+                timeout,
+                timestamp: Date.now()
+            });
+            this.send(request);
+        });
+    }
+    /**
+     * Send a JSON-RPC notification (no response expected)
+     *
+     * @param notification - JSON-RPC notification
+     *
+     * @example
+     * ```typescript
+     * connection.sendNotification({
+     *   jsonrpc: '2.0',
+     *   method: 'kadi.heartbeat',
+     *   params: { timestamp: Date.now() }
+     * });
+     * ```
+     */
+    sendNotification(notification) {
+        if (!this.isConnected) {
+            throw new KadiError('Not connected to broker', ErrorCode.BROKER_NOT_CONNECTED, 503, { broker: this.config.name });
+        }
+        this.send(notification);
+    }
+    /**
+     * Send a tool result back to broker as JSON-RPC response
+     *
+     * Used when this client acts as a tool provider and needs to respond to invocations.
+     * The requestId must match the incoming request's id field for proper routing.
+     *
+     * @param requestId - Request ID to respond to (CRITICAL: must match incoming request id)
+     * @param result - Result data to send back
+     */
+    sendResponse(requestId, result) {
+        if (!requestId) {
+            // No ID = broker can't route response, so silently drop
+            return;
+        }
+        if (!this.isConnected) {
+            throw new KadiError('Not connected to broker', ErrorCode.BROKER_NOT_CONNECTED, 503, { broker: this.config.name });
+        }
+        // Send proper JSON-RPC response with matching id
+        const response = {
+            jsonrpc: '2.0',
+            result,
+            id: requestId
+        };
+        this.send(response);
+    }
+    /**
+     * Send a tool error back to broker as JSON-RPC error response
+     *
+     * Used when tool execution fails and we need to report the error back.
+     * The requestId must match the incoming request's id field for proper routing.
+     *
+     * @param requestId - Request ID to respond to (CRITICAL: must match incoming request id)
+     * @param code - Error code (e.g., ErrorCode.TOOL_NOT_FOUND)
+     * @param message - Human-readable error message
+     * @param data - Optional additional error context
+     */
+    sendError(requestId, code, message, data) {
+        if (!requestId) {
+            // No ID = broker can't route error, so silently drop
+            return;
+        }
+        if (!this.isConnected) {
+            throw new KadiError('Not connected to broker', ErrorCode.BROKER_NOT_CONNECTED, 503, { broker: this.config.name });
+        }
+        // Send proper JSON-RPC error response with matching id
+        const response = {
+            jsonrpc: '2.0',
+            error: {
+                code: -32000, // Application error code range
+                message: `${code}: ${message}`,
+                data
+            },
+            id: requestId
+        };
+        this.send(response);
+    }
+    /**
+     * Send raw data to broker
+     *
+     * @param data - Data to send (request, response, or notification)
+     */
+    send(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new KadiError('WebSocket not open', ErrorCode.BROKER_NOT_CONNECTED, 503, { broker: this.config.name });
+        }
+        try {
+            const message = JSON.stringify(data);
+            this.ws.send(message);
+        }
+        catch (error) {
+            throw new KadiError(`Failed to send message: ${error instanceof Error ? error.message : String(error)}`, ErrorCode.TRANSPORT_SEND_FAILED, 500, { broker: this.config.name });
+        }
+    }
+    /**
+     * Handle incoming WebSocket message
+     *
+     * @param data - Raw message data
+     */
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data.toString());
+            // Check if this is a response to a pending request
+            if ('id' in message && message.id !== undefined) {
+                const pending = this.pendingRequests.get(message.id);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.pendingRequests.delete(message.id);
+                    const response = message;
+                    if (response.error) {
+                        pending.reject(new KadiError(response.error.message, ErrorCode.BROKER_RESPONSE_ERROR, 500, { broker: this.config.name, errorCode: response.error.code, errorData: response.error.data }));
+                    }
+                    else {
+                        pending.resolve(response.result);
+                    }
+                    return;
+                }
+            }
+            // Emit as general message (notification or unsolicited response)
+            this.emit('message', message);
+        }
+        catch (error) {
+            this.emit('error', new KadiError(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`, ErrorCode.INVALID_MESSAGE_FORMAT, 400, { broker: this.config.name }));
+        }
+    }
+    /**
+     * Handle WebSocket close event
+     *
+     * @param code - Close code
+     * @param reason - Close reason
+     */
+    handleClose(code, reason) {
+        this.setState(ConnectionState.DISCONNECTED);
+        this.cleanup();
+        this.emit('disconnected', code, reason);
+    }
+    /**
+     * Setup heartbeat timer
+     */
+    setupHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+        }
+        if (this.config.heartbeatInterval && this.config.heartbeatInterval > 0) {
+            this.heartbeatTimer = setInterval(() => {
+                this._lastHeartbeat = Date.now();
+                // Heartbeat logic handled by BrokerProtocol
+            }, this.config.heartbeatInterval);
+        }
+    }
+    /**
+     * Cleanup connection resources
+     */
+    cleanup() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new KadiError('Connection closed', ErrorCode.CONNECTION_CLOSED, 503, { broker: this.config.name, requestId: id }));
+        }
+        this.pendingRequests.clear();
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+        this._connectedAt = null;
+        this._lastHeartbeat = null;
+        this.setState(ConnectionState.DISCONNECTED);
+    }
+    /**
+     * Set connection state and emit event
+     *
+     * @param newState - New state
+     */
+    setState(newState) {
+        const oldState = this._state;
+        if (oldState !== newState) {
+            this._state = newState;
+            this.emit('stateChange', oldState, newState);
+        }
+    }
+    /**
+     * Get broker name
+     */
+    get name() {
+        return this.config.name;
+    }
+    /**
+     * Get broker URL
+     */
+    get url() {
+        return this.config.url;
+    }
+    /**
+     * Get current connection state
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Check if connected
+     */
+    get isConnected() {
+        return this._state === ConnectionState.CONNECTED || this._state === ConnectionState.AUTHENTICATED;
+    }
+    /**
+     * Get assigned agent ID
+     */
+    get agentId() {
+        return this._agentId;
+    }
+    /**
+     * Set agent ID (called after handshake)
+     */
+    set agentId(id) {
+        this._agentId = id;
+    }
+    /**
+     * Get connection timestamp
+     */
+    get connectedAt() {
+        return this._connectedAt;
+    }
+    /**
+     * Get last heartbeat timestamp
+     */
+    get lastHeartbeat() {
+        return this._lastHeartbeat;
+    }
+}
+//# sourceMappingURL=BrokerConnection.js.map