agentic-qe 3.3.4 → 3.4.0

package/v3/dist/adapters/ag-ui/stream-controller.d.ts

@@ -0,0 +1,195 @@
+/**
+ * AG-UI Stream Controller
+ *
+ * Provides flow control and cancellation handling for AG-UI event streaming.
+ * Wraps EventAdapter with AbortSignal support, token buffering, and graceful shutdown.
+ *
+ * @module adapters/ag-ui/stream-controller
+ */
+import { EventEmitter } from 'events';
+import type { AGUIEvent } from './event-types.js';
+import type { EventAdapter } from './event-adapter.js';
+import type { BackpressureHandler } from './backpressure-handler.js';
+/**
+ * Stream controller configuration
+ */
+export interface StreamControllerConfig {
+    /** EventAdapter instance to wrap */
+    adapter: EventAdapter;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Callback invoked when stream is cancelled */
+    onCancel?: () => Promise<void> | void;
+    /** Callback invoked when stream ends */
+    onEnd?: (reason: 'success' | 'cancelled' | 'error') => Promise<void> | void;
+    /** Callback invoked on stream error */
+    onError?: (error: Error) => Promise<void> | void;
+    /** Token buffering interval in milliseconds (default: 50ms for 20fps) */
+    bufferInterval?: number;
+    /** Maximum buffer size before flushing (default: 10) */
+    maxBufferSize?: number;
+    /** Optional backpressure handler */
+    backpressureHandler?: BackpressureHandler;
+    /** Whether to automatically emit RUN_FINISHED on cancel */
+    emitFinishOnCancel?: boolean;
+}
+/**
+ * Stream state
+ */
+export type StreamState = 'idle' | 'streaming' | 'paused' | 'cancelled' | 'ended' | 'error';
+/**
+ * Stream metrics
+ */
+export interface StreamMetrics {
+    /** Total events processed */
+    totalEvents: number;
+    /** Events buffered and flushed */
+    bufferedEvents: number;
+    /** Events dropped (if backpressure applied) */
+    droppedEvents: number;
+    /** Average latency in milliseconds */
+    averageLatencyMs: number;
+    /** Peak latency in milliseconds */
+    peakLatencyMs: number;
+    /** Stream start time */
+    startTime: number;
+    /** Stream duration in milliseconds */
+    durationMs: number;
+    /** Buffer flush count */
+    flushCount: number;
+}
+/**
+ * AG-UI Stream Controller
+ *
+ * Wraps an EventAdapter to provide:
+ * - AbortController/AbortSignal based cancellation
+ * - Token buffering at configurable intervals
+ * - Graceful shutdown on client disconnect
+ * - Integration with backpressure handling
+ */
+export declare class StreamController extends EventEmitter {
+    private readonly adapter;
+    private readonly signal?;
+    private readonly onCancelCallback?;
+    private readonly onEndCallback?;
+    private readonly onErrorCallback?;
+    private readonly bufferInterval;
+    private readonly maxBufferSize;
+    private readonly backpressureHandler?;
+    private readonly emitFinishOnCancel;
+    private state;
+    private buffer;
+    private flushTimer;
+    private abortHandler;
+    private metrics;
+    constructor(config: StreamControllerConfig);
+    /**
+     * Start the stream
+     */
+    start(): void;
+    /**
+     * Pause the stream (buffers events but doesn't emit)
+     */
+    pause(): void;
+    /**
+     * Resume the stream
+     */
+    resume(): void;
+    /**
+     * Cancel the stream
+     */
+    cancel(): Promise<void>;
+    /**
+     * End the stream gracefully
+     */
+    end(reason?: 'success' | 'error'): Promise<void>;
+    /**
+     * Handle error in stream
+     */
+    handleError(error: Error): Promise<void>;
+    /**
+     * Push an event to the stream
+     * Returns false if backpressure is applied and event should not be produced
+     */
+    push(event: AGUIEvent): boolean;
+    /**
+     * Flush the event buffer
+     */
+    flush(): void;
+    /**
+     * Get current stream state
+     */
+    getState(): StreamState;
+    /**
+     * Check if stream is active
+     */
+    isActive(): boolean;
+    /**
+     * Check if stream is cancelled
+     */
+    isCancelled(): boolean;
+    /**
+     * Get stream metrics
+     */
+    getMetrics(): Readonly<StreamMetrics>;
+    /**
+     * Get buffer size
+     */
+    getBufferSize(): number;
+    /**
+     * Get the wrapped adapter
+     */
+    getAdapter(): EventAdapter;
+    /**
+     * Dispose of the stream controller
+     */
+    dispose(): void;
+    private setupSignalHandler;
+    private removeAbortHandler;
+    private setupAdapterListeners;
+    private scheduleFlush;
+    private clearFlushTimer;
+    private initializeMetrics;
+    private updateLatencyMetrics;
+}
+/**
+ * Create a new StreamController instance
+ *
+ * @param config - Stream controller configuration
+ * @returns StreamController instance
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ * const stream = createStreamController({
+ *   adapter: eventAdapter,
+ *   signal: controller.signal,
+ *   onCancel: async () => {
+ *     await agent.abort();
+ *   }
+ * });
+ *
+ * stream.start();
+ *
+ * // Later, to cancel:
+ * controller.abort();
+ * // -> onCancel called
+ * // -> RUN_FINISHED emitted with reason: 'cancelled'
+ * // -> Stream closed gracefully
+ * ```
+ */
+export declare function createStreamController(config: StreamControllerConfig): StreamController;
+/**
+ * Create an async iterator from a stream controller
+ * Allows using for-await-of syntax to consume events
+ */
+export declare function streamEvents(controller: StreamController): AsyncGenerator<AGUIEvent, void, unknown>;
+/**
+ * Create a transform stream from a stream controller
+ * For integration with Node.js streams API
+ */
+export declare function createEventTransform(controller: StreamController): {
+    readable: ReadableStream<AGUIEvent>;
+    writable: WritableStream<AGUIEvent>;
+};
+//# sourceMappingURL=stream-controller.d.ts.map

package/v3/dist/adapters/ag-ui/stream-controller.d.ts.map

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

package/v3/dist/adapters/ag-ui/stream-controller.js

@@ -0,0 +1,481 @@
+/**
+ * AG-UI Stream Controller
+ *
+ * Provides flow control and cancellation handling for AG-UI event streaming.
+ * Wraps EventAdapter with AbortSignal support, token buffering, and graceful shutdown.
+ *
+ * @module adapters/ag-ui/stream-controller
+ */
+import { EventEmitter } from 'events';
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    bufferInterval: 50, // 50ms = 20fps
+    maxBufferSize: 10,
+    emitFinishOnCancel: true,
+};
+// ============================================================================
+// Stream Controller Implementation
+// ============================================================================
+/**
+ * AG-UI Stream Controller
+ *
+ * Wraps an EventAdapter to provide:
+ * - AbortController/AbortSignal based cancellation
+ * - Token buffering at configurable intervals
+ * - Graceful shutdown on client disconnect
+ * - Integration with backpressure handling
+ */
+export class StreamController extends EventEmitter {
+    adapter;
+    signal;
+    onCancelCallback;
+    onEndCallback;
+    onErrorCallback;
+    bufferInterval;
+    maxBufferSize;
+    backpressureHandler;
+    emitFinishOnCancel;
+    state = 'idle';
+    buffer = [];
+    flushTimer = null;
+    abortHandler = null;
+    metrics;
+    constructor(config) {
+        super();
+        this.adapter = config.adapter;
+        this.signal = config.signal;
+        this.onCancelCallback = config.onCancel;
+        this.onEndCallback = config.onEnd;
+        this.onErrorCallback = config.onError;
+        this.bufferInterval = config.bufferInterval ?? DEFAULT_CONFIG.bufferInterval;
+        this.maxBufferSize = config.maxBufferSize ?? DEFAULT_CONFIG.maxBufferSize;
+        this.backpressureHandler = config.backpressureHandler;
+        this.emitFinishOnCancel = config.emitFinishOnCancel ?? DEFAULT_CONFIG.emitFinishOnCancel;
+        this.metrics = this.initializeMetrics();
+        this.setupSignalHandler();
+        this.setupAdapterListeners();
+    }
+    // ============================================================================
+    // Lifecycle Methods
+    // ============================================================================
+    /**
+     * Start the stream
+     */
+    start() {
+        if (this.state !== 'idle') {
+            throw new Error(`Cannot start stream in state: ${this.state}`);
+        }
+        this.state = 'streaming';
+        this.metrics.startTime = Date.now();
+        this.emit('start');
+    }
+    /**
+     * Pause the stream (buffers events but doesn't emit)
+     */
+    pause() {
+        if (this.state !== 'streaming') {
+            return;
+        }
+        this.state = 'paused';
+        this.emit('pause');
+    }
+    /**
+     * Resume the stream
+     */
+    resume() {
+        if (this.state !== 'paused') {
+            return;
+        }
+        this.state = 'streaming';
+        this.emit('resume');
+        // Flush any buffered events
+        this.flush();
+    }
+    /**
+     * Cancel the stream
+     */
+    async cancel() {
+        if (this.state === 'cancelled' || this.state === 'ended' || this.state === 'error') {
+            return;
+        }
+        this.state = 'cancelled';
+        this.clearFlushTimer();
+        // Call cancel callback
+        if (this.onCancelCallback) {
+            try {
+                await this.onCancelCallback();
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }
+        // Emit RUN_FINISHED with cancelled outcome
+        if (this.emitFinishOnCancel) {
+            const runId = this.adapter.getCurrentRunId();
+            if (runId) {
+                const finishEvent = this.adapter.emitRunFinished(runId, 'cancelled');
+                this.emit('event', finishEvent);
+            }
+        }
+        // Flush remaining buffer
+        this.flush();
+        this.emit('cancel');
+        // Call end callback
+        if (this.onEndCallback) {
+            try {
+                await this.onEndCallback('cancelled');
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }
+    }
+    /**
+     * End the stream gracefully
+     */
+    async end(reason = 'success') {
+        if (this.state === 'cancelled' || this.state === 'ended' || this.state === 'error') {
+            return;
+        }
+        this.state = reason === 'error' ? 'error' : 'ended';
+        this.clearFlushTimer();
+        // Flush remaining buffer
+        this.flush();
+        this.metrics.durationMs = Date.now() - this.metrics.startTime;
+        this.emit('end', reason);
+        // Call end callback
+        if (this.onEndCallback) {
+            try {
+                await this.onEndCallback(reason);
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }
+    }
+    /**
+     * Handle error in stream
+     */
+    async handleError(error) {
+        if (this.state === 'cancelled' || this.state === 'ended' || this.state === 'error') {
+            return;
+        }
+        this.state = 'error';
+        this.clearFlushTimer();
+        // Call error callback
+        if (this.onErrorCallback) {
+            try {
+                await this.onErrorCallback(error);
+            }
+            catch (callbackError) {
+                // Emit original error, not callback error
+            }
+        }
+        this.emit('error', error);
+        await this.end('error');
+    }
+    // ============================================================================
+    // Event Handling
+    // ============================================================================
+    /**
+     * Push an event to the stream
+     * Returns false if backpressure is applied and event should not be produced
+     */
+    push(event) {
+        if (this.state !== 'streaming' && this.state !== 'paused') {
+            return false;
+        }
+        // Check backpressure
+        if (this.backpressureHandler) {
+            const accepted = this.backpressureHandler.push(event);
+            if (!accepted) {
+                this.metrics.droppedEvents++;
+                return false;
+            }
+        }
+        const bufferedEvent = {
+            event,
+            timestamp: Date.now(),
+        };
+        this.buffer.push(bufferedEvent);
+        this.metrics.bufferedEvents++;
+        this.metrics.totalEvents++;
+        // Schedule flush if not already scheduled
+        if (!this.flushTimer && this.state === 'streaming') {
+            this.scheduleFlush();
+        }
+        // Force flush if buffer exceeds max size
+        if (this.buffer.length >= this.maxBufferSize) {
+            this.flush();
+        }
+        return true;
+    }
+    /**
+     * Flush the event buffer
+     */
+    flush() {
+        this.clearFlushTimer();
+        if (this.buffer.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        const eventsToFlush = [...this.buffer];
+        this.buffer = [];
+        this.metrics.flushCount++;
+        // Calculate latency metrics
+        for (const { event, timestamp } of eventsToFlush) {
+            const latency = now - timestamp;
+            this.updateLatencyMetrics(latency);
+            // Emit event
+            if (this.state === 'streaming' || this.state === 'cancelled' || this.state === 'ended') {
+                this.emit('event', event);
+            }
+        }
+        this.emit('flush', eventsToFlush.length);
+    }
+    // ============================================================================
+    // State and Metrics
+    // ============================================================================
+    /**
+     * Get current stream state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Check if stream is active
+     */
+    isActive() {
+        return this.state === 'streaming' || this.state === 'paused';
+    }
+    /**
+     * Check if stream is cancelled
+     */
+    isCancelled() {
+        return this.state === 'cancelled';
+    }
+    /**
+     * Get stream metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            durationMs: this.state === 'streaming' || this.state === 'paused'
+                ? Date.now() - this.metrics.startTime
+                : this.metrics.durationMs,
+        };
+    }
+    /**
+     * Get buffer size
+     */
+    getBufferSize() {
+        return this.buffer.length;
+    }
+    /**
+     * Get the wrapped adapter
+     */
+    getAdapter() {
+        return this.adapter;
+    }
+    // ============================================================================
+    // Cleanup
+    // ============================================================================
+    /**
+     * Dispose of the stream controller
+     */
+    dispose() {
+        this.clearFlushTimer();
+        this.removeAbortHandler();
+        this.removeAllListeners();
+        this.buffer = [];
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    setupSignalHandler() {
+        if (!this.signal) {
+            return;
+        }
+        // Check if already aborted
+        if (this.signal.aborted) {
+            // Use setImmediate to allow constructor to complete
+            setImmediate(() => this.cancel());
+            return;
+        }
+        // Setup abort handler
+        this.abortHandler = () => {
+            this.cancel();
+        };
+        this.signal.addEventListener('abort', this.abortHandler);
+    }
+    removeAbortHandler() {
+        if (this.signal && this.abortHandler) {
+            this.signal.removeEventListener('abort', this.abortHandler);
+            this.abortHandler = null;
+        }
+    }
+    setupAdapterListeners() {
+        // Forward events from adapter to stream
+        this.adapter.on('event', (event) => {
+            this.push(event);
+        });
+        // Forward errors
+        this.adapter.on('error', (error) => {
+            this.handleError(error);
+        });
+    }
+    scheduleFlush() {
+        if (this.flushTimer) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            if (this.state === 'streaming') {
+                this.flush();
+            }
+        }, this.bufferInterval);
+    }
+    clearFlushTimer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    initializeMetrics() {
+        return {
+            totalEvents: 0,
+            bufferedEvents: 0,
+            droppedEvents: 0,
+            averageLatencyMs: 0,
+            peakLatencyMs: 0,
+            startTime: 0,
+            durationMs: 0,
+            flushCount: 0,
+        };
+    }
+    updateLatencyMetrics(latency) {
+        // Update peak
+        if (latency > this.metrics.peakLatencyMs) {
+            this.metrics.peakLatencyMs = latency;
+        }
+        // Update rolling average
+        const totalSamples = this.metrics.flushCount || 1;
+        this.metrics.averageLatencyMs =
+            (this.metrics.averageLatencyMs * (totalSamples - 1) + latency) / totalSamples;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create a new StreamController instance
+ *
+ * @param config - Stream controller configuration
+ * @returns StreamController instance
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ * const stream = createStreamController({
+ *   adapter: eventAdapter,
+ *   signal: controller.signal,
+ *   onCancel: async () => {
+ *     await agent.abort();
+ *   }
+ * });
+ *
+ * stream.start();
+ *
+ * // Later, to cancel:
+ * controller.abort();
+ * // -> onCancel called
+ * // -> RUN_FINISHED emitted with reason: 'cancelled'
+ * // -> Stream closed gracefully
+ * ```
+ */
+export function createStreamController(config) {
+    return new StreamController(config);
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Create an async iterator from a stream controller
+ * Allows using for-await-of syntax to consume events
+ */
+export async function* streamEvents(controller) {
+    const events = [];
+    let resolveNext = null;
+    let done = false;
+    const eventHandler = (event) => {
+        events.push(event);
+        if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+        }
+    };
+    const endHandler = () => {
+        done = true;
+        if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+        }
+    };
+    controller.on('event', eventHandler);
+    controller.on('end', endHandler);
+    controller.on('cancel', endHandler);
+    try {
+        while (!done || events.length > 0) {
+            if (events.length > 0) {
+                yield events.shift();
+            }
+            else if (!done) {
+                await new Promise((resolve) => {
+                    resolveNext = resolve;
+                });
+            }
+        }
+    }
+    finally {
+        controller.off('event', eventHandler);
+        controller.off('end', endHandler);
+        controller.off('cancel', endHandler);
+    }
+}
+/**
+ * Create a transform stream from a stream controller
+ * For integration with Node.js streams API
+ */
+export function createEventTransform(controller) {
+    const readable = new ReadableStream({
+        start(streamController) {
+            controller.on('event', (event) => {
+                streamController.enqueue(event);
+            });
+            controller.on('end', () => {
+                streamController.close();
+            });
+            controller.on('cancel', () => {
+                streamController.close();
+            });
+            controller.on('error', (error) => {
+                streamController.error(error);
+            });
+        },
+    });
+    const writable = new WritableStream({
+        write(event) {
+            controller.push(event);
+        },
+        close() {
+            controller.end();
+        },
+        abort(reason) {
+            controller.cancel();
+        },
+    });
+    return { readable, writable };
+}
+//# sourceMappingURL=stream-controller.js.map