@continue-reasoning/agent/dist/src/agentEvent.d.ts

A platform-agnostic AI agent framework for building autonomous AI agents with tool execution capabilities

/**
 * @fileoverview Agent Event System Implementation
 *
 * This module provides a comprehensive event system for AI agents, enabling
 * real-time monitoring, debugging, and integration with external systems.
 * The event system supports various event types and provides utilities for
 * event handling and filtering.
 */
import { AgentEvent, AgentEventType, EventHandler } from './interfaces.js';
/**
 * Agent event factory and utilities
 *
 * This class provides factory methods for creating different types of agent events
 * and utilities for event handling. It ensures consistent event structure and
 * provides type-safe event creation.
 *
 * Key features:
 * - Type-safe event creation
 * - Consistent metadata handling
 * - Event validation and sanitization
 * - Utility methods for common patterns
 *
 * @example
 * ```typescript
 * const eventFactory = new AgentEventFactory('agent-123');
 *
 * // Create content event
 * const contentEvent = eventFactory.createContentEvent('user_input', 'Hello world', {
 *   sessionId: 'session-1',
 *   turn: 1,
 * });
 *
 * // Create tool call event
 * const toolEvent = eventFactory.createToolCallRequestEvent(toolCallRequest, {
 *   sessionId: 'session-1',
 * });
 * ```
 */
export declare class AgentEventFactory {
    private readonly agentId;
    constructor(agentId: string);
    /**
     * Create a generic event
     *
     * Low-level method for creating events with any type and data.
     *
     * @param type - Event type
     * @param data - Event data
     * @param customMetadata - Custom metadata to merge
     * @returns AgentEvent
     */
    createEvent(type: AgentEventType, data?: unknown, customMetadata?: Record<string, unknown>): AgentEvent;
}
/**
 * Event emitter for agents
 *
 * Manages event handlers and provides methods for emitting events
 * to registered handlers. Supports filtering and error handling.
 *
 * @example
 * ```typescript
 * const emitter = new AgentEventEmitter();
 *
 * // Register handlers
 * emitter.on('content', (event) => console.log('Content:', event.data));
 * emitter.on('error', (event) => console.error('Error:', event.data));
 *
 * // Emit events
 * emitter.emit(eventFactory.createContentEvent('user_input', 'Hello'));
 * ```
 */
export declare class AgentEventEmitter {
    private handlers;
    private typeFilters;
    /**
     * Register an event handler
     *
     * @param id - Unique handler identifier
     * @param handler - Event handler function
     * @param eventTypes - Optional event type filter
     */
    on(id: string, handler: EventHandler, eventTypes?: AgentEventType[]): void;
    /**
     * Remove an event handler
     *
     * @param id - Handler identifier to remove
     */
    off(id: string): void;
    /**
     * Emit an event to all registered handlers
     *
     * Calls all registered handlers that match the event type filter.
     * Handles errors in individual handlers without affecting others.
     *
     * @param event - Event to emit
     */
    emit(event: AgentEvent): void;
    /**
     * Emit event to all handlers except specified one
     *
     * @param event - Event to emit
     * @param excludeId - Handler ID to exclude
     */
    private emitToOthers;
    /**
     * Get all registered handler IDs
     *
     * @returns Array of handler IDs
     */
    getHandlerIds(): string[];
    /**
     * Get handler count
     *
     * @returns Number of registered handlers
     */
    getHandlerCount(): number;
    /**
     * Check if a handler is registered
     *
     * @param id - Handler ID to check
     * @returns True if handler is registered
     */
    hasHandler(id: string): boolean;
    /**
     * Clear all handlers
     */
    clear(): void;
}
/**
 * Event utilities and helpers
 */
export declare class AgentEventUtils {
    /**
     * Check if event is a content event
     *
     * @param event - Event to check
     * @returns True if event is content type
     */
    static isUserMessageEvent(event: AgentEvent): boolean;
    static isAssistantMessageEvent(event: AgentEvent): boolean;
    static isTurnCompleteEvent(event: AgentEvent): boolean;
    static isHistoryClearedEvent(event: AgentEvent): boolean;
    static isSystemPromptSetEvent(event: AgentEvent): boolean;
    /**
     * Check if event is a tool call event
     *
     * @param event - Event to check
     * @returns True if event is tool call type
     */
    static isToolCallEvent(event: AgentEvent): boolean;
    /**
     * Check if event is an error event
     *
     * @param event - Event to check
     * @returns True if event is error type
     */
    static isErrorEvent(event: AgentEvent): boolean;
    /**
     * Extract content from content event
     *
     * @param event - Content event
     * @returns Content string or null if not a content event
     */
    static extractAssistantMessage(event: AgentEvent): string | null;
    /**
     * Extract error message from error event
     *
     * @param event - Error event
     * @returns Error message or null if not an error event
     */
    static extractError(event: AgentEvent): string | null;
    /**
     * Format event for logging
     *
     * @param event - Event to format
     * @returns Formatted event string
     */
    static formatForLogging(event: AgentEvent): string;
    /**
     * Create event filter function
     *
     * @param types - Event types to include
     * @returns Filter function
     */
    static createTypeFilter(types: AgentEventType[]): (event: AgentEvent) => boolean;
    /**
     * Create event aggregator
     *
     * @param windowMs - Time window in milliseconds
     * @returns Aggregator function that collects events in time windows
     */
    static createEventAggregator(windowMs: number): {
        add: (event: AgentEvent) => void;
        getEvents: () => AgentEvent[];
        clear: () => void;
    };
}
//# sourceMappingURL=agentEvent.d.ts.map