agentic-qe 3.3.4 → 3.4.0

package/v3/dist/adapters/ag-ui/event-adapter.js

@@ -0,0 +1,1083 @@
+/**
+ * AG-UI Event Adapter
+ *
+ * Maps AQE v3 events to AG-UI Protocol 1.0 event taxonomy.
+ * Supports bidirectional event ID mapping and multi-agent scenarios.
+ *
+ * @module adapters/ag-ui/event-adapter
+ */
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import { isAQEToolProgress, isAQEToolResult, isAQEAgentStarted, isAQEAgentCompleted, isAQEAgentError, isAQEDomainEvent, } from './event-types.js';
+import { createEventBatcher, } from './event-batcher.js';
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    defaultThreadId: 'default',
+    emitRawForUnknown: true,
+    trackMessageState: true,
+    trackActivityState: true,
+    eventIdGenerator: () => uuidv4(),
+    timestampGenerator: () => new Date().toISOString(),
+    validateEvents: true,
+    maxBufferSize: 1000,
+    enableBatching: true,
+    batcherConfig: {},
+};
+// ============================================================================
+// Event Adapter Implementation
+// ============================================================================
+/**
+ * AG-UI Event Adapter
+ *
+ * Adapts AQE v3 events to AG-UI Protocol 1.0 event format.
+ * Emits events via EventEmitter pattern for streaming support.
+ */
+export class EventAdapter extends EventEmitter {
+    config;
+    // ID Mapping (bidirectional)
+    aqeToAgui = new Map();
+    aguiToAqe = new Map();
+    idMappings = [];
+    // Run tracking
+    activeRuns = new Map();
+    currentRunId = null;
+    // Message tracking
+    messageStates = new Map();
+    // Tool call tracking
+    toolCallStates = new Map();
+    // Activity tracking
+    activities = [];
+    // Event buffer for streaming
+    eventBuffer = [];
+    // Step progress tracking (for ToolProgress -> STEP events)
+    stepProgress = new Map();
+    // Event batcher for reduced network overhead
+    eventBatcher;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Initialize event batcher for batched event emission
+        if (this.config.enableBatching) {
+            this.eventBatcher = createEventBatcher({
+                ...this.config.batcherConfig,
+                onFlush: (batch) => this.handleBatchFlush(batch),
+            });
+            // Forward batcher events
+            this.eventBatcher.on('batch', (batch) => {
+                this.emit('batch', batch);
+            });
+            this.eventBatcher.on('single', (event) => {
+                this.emit('single', event);
+            });
+        }
+        else {
+            this.eventBatcher = null;
+        }
+    }
+    /**
+     * Handle batch flush - emit batch to consumers
+     */
+    handleBatchFlush(batch) {
+        // Emit the entire batch for consumers that support batching
+        this.emit('batchFlush', batch);
+        // Also emit individual events for backward compatibility
+        for (const event of batch.events) {
+            this.emit('event', event);
+            this.emit(event.type, event);
+        }
+    }
+    // ============================================================================
+    // Main Adaptation Method
+    // ============================================================================
+    /**
+     * Adapt an AQE event to AG-UI events
+     *
+     * @param event - Source AQE event
+     * @returns Array of AG-UI events (may be empty or multiple)
+     */
+    adapt(event) {
+        const events = [];
+        try {
+            if (isAQEToolProgress(event)) {
+                events.push(...this.adaptToolProgress(event));
+            }
+            else if (isAQEToolResult(event)) {
+                events.push(...this.adaptToolResult(event));
+            }
+            else if (isAQEAgentStarted(event)) {
+                events.push(...this.adaptAgentStarted(event));
+            }
+            else if (isAQEAgentCompleted(event)) {
+                events.push(...this.adaptAgentCompleted(event));
+            }
+            else if (isAQEAgentError(event)) {
+                events.push(...this.adaptAgentError(event));
+            }
+            else if (isAQEDomainEvent(event)) {
+                events.push(...this.adaptDomainEvent(event));
+            }
+            else if (this.config.emitRawForUnknown) {
+                events.push(this.createRawEvent(event));
+            }
+            // Validate and emit events
+            for (const aguiEvent of events) {
+                if (this.config.validateEvents) {
+                    this.validateEvent(aguiEvent);
+                }
+                this.emitEvent(aguiEvent);
+                this.bufferEvent(aguiEvent);
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+        return events;
+    }
+    // ============================================================================
+    // Adaptation Methods by Event Type
+    // ============================================================================
+    /**
+     * Adapt ToolProgress to STEP_STARTED / TEXT_MESSAGE_CONTENT
+     */
+    adaptToolProgress(event) {
+        const events = [];
+        const runId = this.currentRunId ?? this.createOrGetRunId();
+        const stepId = event.stepId ?? this.generateId();
+        // Check if this is a new step or continuation
+        const existingProgress = this.stepProgress.get(stepId);
+        const isNewStep = existingProgress === undefined;
+        if (isNewStep) {
+            // Emit STEP_STARTED for new steps
+            const stepStarted = {
+                type: 'STEP_STARTED',
+                eventId: this.generateEventId(),
+                timestamp: this.generateTimestamp(),
+                runId,
+                stepId,
+                name: event.toolName ?? 'Processing',
+                metadata: {
+                    initialProgress: event.percent,
+                    message: event.message,
+                },
+            };
+            events.push(stepStarted);
+            // Track step in active run
+            const runContext = this.activeRuns.get(runId);
+            if (runContext) {
+                runContext.activeSteps.add(stepId);
+            }
+        }
+        // Update progress tracking
+        this.stepProgress.set(stepId, event.percent);
+        // Emit TEXT_MESSAGE_CONTENT for progress updates
+        const messageId = this.getOrCreateMessageId(stepId);
+        const contentEvent = {
+            type: 'TEXT_MESSAGE_CONTENT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            messageId,
+            delta: event.message,
+        };
+        events.push(contentEvent);
+        // Emit STEP_FINISHED if 100% complete
+        if (event.percent >= 100) {
+            const stepFinished = {
+                type: 'STEP_FINISHED',
+                eventId: this.generateEventId(),
+                timestamp: this.generateTimestamp(),
+                runId,
+                stepId,
+                result: { message: event.message, percent: event.percent },
+            };
+            events.push(stepFinished);
+            // Clean up tracking
+            this.stepProgress.delete(stepId);
+            const runContext = this.activeRuns.get(runId);
+            if (runContext) {
+                runContext.activeSteps.delete(stepId);
+            }
+        }
+        return events;
+    }
+    /**
+     * Adapt ToolResult to TOOL_CALL_RESULT
+     */
+    adaptToolResult(event) {
+        const events = [];
+        const toolCallId = event.metadata?.requestId ?? this.generateId();
+        const messageId = this.generateId();
+        // Create TOOL_CALL_RESULT
+        const resultEvent = {
+            type: 'TOOL_CALL_RESULT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            toolCallId,
+            messageId,
+            content: JSON.stringify(event.data ?? {}),
+            success: event.success,
+            error: event.error,
+        };
+        events.push(resultEvent);
+        // Update tool call state
+        const toolCallState = this.toolCallStates.get(toolCallId);
+        if (toolCallState) {
+            toolCallState.complete = true;
+            toolCallState.result = resultEvent.content;
+        }
+        // Store ID mapping
+        if (event.metadata?.requestId) {
+            this.storeIdMapping(event.metadata.requestId, toolCallId, 'tool_call');
+        }
+        return events;
+    }
+    /**
+     * Adapt AgentStarted to RUN_STARTED
+     */
+    adaptAgentStarted(event) {
+        const runId = this.generateId();
+        const threadId = this.config.defaultThreadId;
+        // Create run context
+        const runContext = {
+            runId,
+            threadId,
+            startedAt: event.timestamp,
+            agentId: event.agentId,
+            domain: event.domain,
+            activeSteps: new Set(),
+            activeMessages: new Set(),
+            activeToolCalls: new Set(),
+        };
+        this.activeRuns.set(runId, runContext);
+        this.currentRunId = runId;
+        // Store ID mapping
+        this.storeIdMapping(event.agentId, runId, 'run');
+        // Create RUN_STARTED event
+        const runStarted = {
+            type: 'RUN_STARTED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            threadId,
+            runId,
+            input: event.task,
+            metadata: {
+                agentId: event.agentId,
+                domain: event.domain,
+            },
+        };
+        return [runStarted];
+    }
+    /**
+     * Adapt AgentCompleted to RUN_FINISHED
+     */
+    adaptAgentCompleted(event) {
+        const runId = this.getAguiId(event.agentId) ?? this.currentRunId ?? this.generateId();
+        // Create RUN_FINISHED event
+        const runFinished = {
+            type: 'RUN_FINISHED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId,
+            outcome: 'success',
+            result: event.result,
+        };
+        // Clean up run context
+        this.activeRuns.delete(runId);
+        if (this.currentRunId === runId) {
+            this.currentRunId = null;
+        }
+        return [runFinished];
+    }
+    /**
+     * Adapt AgentError to RUN_ERROR
+     */
+    adaptAgentError(event) {
+        const runId = this.getAguiId(event.agentId) ?? this.currentRunId ?? this.generateId();
+        // Create RUN_ERROR event
+        const runError = {
+            type: 'RUN_ERROR',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId,
+            message: event.error,
+            code: event.code ?? 'AGENT_ERROR',
+            recoverable: event.recoverable,
+        };
+        // Clean up run context
+        this.activeRuns.delete(runId);
+        if (this.currentRunId === runId) {
+            this.currentRunId = null;
+        }
+        return [runError];
+    }
+    /**
+     * Adapt DomainEvent to appropriate AG-UI events
+     */
+    adaptDomainEvent(event) {
+        const events = [];
+        // Map domain event types to AG-UI events
+        const eventType = event.type.toLowerCase();
+        if (eventType.includes('started') || eventType.includes('running')) {
+            // Map to STEP_STARTED
+            const stepId = event.id;
+            const stepStarted = {
+                type: 'STEP_STARTED',
+                eventId: this.generateEventId(),
+                timestamp: this.generateTimestamp(),
+                runId: this.currentRunId ?? this.createOrGetRunId(),
+                stepId,
+                name: event.type,
+                metadata: event.payload,
+            };
+            events.push(stepStarted);
+            this.storeIdMapping(event.id, stepId, 'step');
+        }
+        else if (eventType.includes('completed') || eventType.includes('finished')) {
+            // Map to STEP_FINISHED
+            const stepId = this.getAguiId(event.id) ?? event.id;
+            const stepFinished = {
+                type: 'STEP_FINISHED',
+                eventId: this.generateEventId(),
+                timestamp: this.generateTimestamp(),
+                runId: this.currentRunId ?? this.config.defaultThreadId,
+                stepId,
+                result: event.payload,
+            };
+            events.push(stepFinished);
+        }
+        else if (eventType.includes('error') || eventType.includes('failed')) {
+            // Map to RUN_ERROR if no active run, otherwise STEP_FINISHED with error
+            if (this.currentRunId) {
+                const stepId = this.getAguiId(event.id) ?? event.id;
+                const stepFinished = {
+                    type: 'STEP_FINISHED',
+                    eventId: this.generateEventId(),
+                    timestamp: this.generateTimestamp(),
+                    runId: this.currentRunId,
+                    stepId,
+                    result: { error: event.payload },
+                };
+                events.push(stepFinished);
+            }
+        }
+        else {
+            // Default: emit as CUSTOM event
+            const customEvent = {
+                type: 'CUSTOM',
+                eventId: this.generateEventId(),
+                timestamp: this.generateTimestamp(),
+                runId: this.currentRunId ?? undefined,
+                name: event.type,
+                value: event.payload,
+            };
+            events.push(customEvent);
+        }
+        return events;
+    }
+    // ============================================================================
+    // Direct Event Emission Methods
+    // ============================================================================
+    /**
+     * Emit RUN_STARTED event directly
+     */
+    emitRunStarted(threadId, runId, input) {
+        const id = runId ?? this.generateId();
+        // Create run context
+        const runContext = {
+            runId: id,
+            threadId,
+            startedAt: this.generateTimestamp(),
+            activeSteps: new Set(),
+            activeMessages: new Set(),
+            activeToolCalls: new Set(),
+        };
+        this.activeRuns.set(id, runContext);
+        this.currentRunId = id;
+        const event = {
+            type: 'RUN_STARTED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            threadId,
+            runId: id,
+            input,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit RUN_FINISHED event directly
+     */
+    emitRunFinished(runId, outcome = 'success', result) {
+        const event = {
+            type: 'RUN_FINISHED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId,
+            outcome,
+            result,
+        };
+        // Clean up
+        this.activeRuns.delete(runId);
+        if (this.currentRunId === runId) {
+            this.currentRunId = null;
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit RUN_ERROR event directly
+     */
+    emitRunError(runId, message, code, recoverable = false) {
+        const event = {
+            type: 'RUN_ERROR',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId,
+            message,
+            code,
+            recoverable,
+        };
+        // Clean up
+        this.activeRuns.delete(runId);
+        if (this.currentRunId === runId) {
+            this.currentRunId = null;
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit STEP_STARTED event directly
+     */
+    emitStepStarted(stepId, name, runId) {
+        const rid = runId ?? this.currentRunId ?? this.createOrGetRunId();
+        const event = {
+            type: 'STEP_STARTED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: rid,
+            stepId,
+            name,
+        };
+        // Track in run context
+        const runContext = this.activeRuns.get(rid);
+        if (runContext) {
+            runContext.activeSteps.add(stepId);
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit STEP_FINISHED event directly
+     */
+    emitStepFinished(stepId, result, runId) {
+        const rid = runId ?? this.currentRunId ?? this.config.defaultThreadId;
+        const event = {
+            type: 'STEP_FINISHED',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: rid,
+            stepId,
+            result,
+        };
+        // Remove from run context
+        const runContext = this.activeRuns.get(rid);
+        if (runContext) {
+            runContext.activeSteps.delete(stepId);
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TEXT_MESSAGE_START event directly
+     */
+    emitTextMessageStart(messageId, role = 'assistant') {
+        const event = {
+            type: 'TEXT_MESSAGE_START',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            messageId,
+            role,
+        };
+        // Track message state
+        if (this.config.trackMessageState) {
+            this.messageStates.set(messageId, {
+                messageId,
+                content: '',
+                role,
+                startedAt: event.timestamp,
+                complete: false,
+            });
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TEXT_MESSAGE_CONTENT event directly
+     */
+    emitTextMessageContent(messageId, delta) {
+        const event = {
+            type: 'TEXT_MESSAGE_CONTENT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            messageId,
+            delta,
+        };
+        // Update message state
+        if (this.config.trackMessageState) {
+            const state = this.messageStates.get(messageId);
+            if (state) {
+                state.content += delta;
+            }
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TEXT_MESSAGE_END event directly
+     */
+    emitTextMessageEnd(messageId) {
+        // Get accumulated content
+        const state = this.messageStates.get(messageId);
+        const content = state?.content;
+        const event = {
+            type: 'TEXT_MESSAGE_END',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            messageId,
+            content,
+        };
+        // Update message state
+        if (state) {
+            state.complete = true;
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TOOL_CALL_START event directly
+     */
+    emitToolCallStart(toolCallId, toolCallName, parentMessageId) {
+        const event = {
+            type: 'TOOL_CALL_START',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            toolCallId,
+            toolCallName,
+            parentMessageId,
+        };
+        // Track tool call state
+        this.toolCallStates.set(toolCallId, {
+            toolCallId,
+            toolName: toolCallName,
+            argsJson: '',
+            startedAt: event.timestamp,
+            complete: false,
+        });
+        // Track in run context
+        const runContext = this.activeRuns.get(this.currentRunId ?? '');
+        if (runContext) {
+            runContext.activeToolCalls.add(toolCallId);
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TOOL_CALL_ARGS event directly
+     */
+    emitToolCallArgs(toolCallId, delta) {
+        const event = {
+            type: 'TOOL_CALL_ARGS',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            toolCallId,
+            delta,
+        };
+        // Update tool call state
+        const state = this.toolCallStates.get(toolCallId);
+        if (state) {
+            state.argsJson += delta;
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TOOL_CALL_END event directly
+     */
+    emitToolCallEnd(toolCallId) {
+        // Get accumulated args
+        const state = this.toolCallStates.get(toolCallId);
+        let args;
+        if (state) {
+            try {
+                args = JSON.parse(state.argsJson);
+                state.args = args;
+            }
+            catch {
+                // Invalid JSON, leave args undefined
+            }
+        }
+        const event = {
+            type: 'TOOL_CALL_END',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            toolCallId,
+            args,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit TOOL_CALL_RESULT event directly
+     */
+    emitToolCallResult(toolCallId, content, messageId, success = true) {
+        const mid = messageId ?? this.generateId();
+        const event = {
+            type: 'TOOL_CALL_RESULT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            toolCallId,
+            messageId: mid,
+            content,
+            success,
+        };
+        // Update tool call state
+        const state = this.toolCallStates.get(toolCallId);
+        if (state) {
+            state.complete = true;
+            state.result = content;
+        }
+        // Remove from run context
+        const runContext = this.activeRuns.get(this.currentRunId ?? '');
+        if (runContext) {
+            runContext.activeToolCalls.delete(toolCallId);
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit STATE_SNAPSHOT event directly
+     */
+    emitStateSnapshot(state, version) {
+        const event = {
+            type: 'STATE_SNAPSHOT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            state,
+            version,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit STATE_DELTA event directly
+     */
+    emitStateDelta(delta, version) {
+        const event = {
+            type: 'STATE_DELTA',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            delta,
+            version,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit MESSAGES_SNAPSHOT event directly
+     */
+    emitMessagesSnapshot(messages) {
+        const event = {
+            type: 'MESSAGES_SNAPSHOT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            messages,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit ACTIVITY_SNAPSHOT event directly
+     */
+    emitActivitySnapshot(activity, replace = false) {
+        const event = {
+            type: 'ACTIVITY_SNAPSHOT',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            activity,
+            replace,
+        };
+        // Update activity tracking
+        if (this.config.trackActivityState) {
+            if (replace) {
+                this.activities = [...activity];
+            }
+            else {
+                this.activities.push(...activity);
+            }
+        }
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit ACTIVITY_DELTA event directly
+     */
+    emitActivityDelta(delta) {
+        const event = {
+            type: 'ACTIVITY_DELTA',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            delta,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit RAW event directly
+     */
+    emitRaw(rawEvent, source) {
+        const event = {
+            type: 'RAW',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            event: rawEvent,
+            source,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    /**
+     * Emit CUSTOM event directly
+     */
+    emitCustom(name, value) {
+        const event = {
+            type: 'CUSTOM',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            name,
+            value,
+        };
+        this.emitEvent(event);
+        this.bufferEvent(event);
+        return event;
+    }
+    // ============================================================================
+    // ID Mapping Methods
+    // ============================================================================
+    /**
+     * Get AG-UI ID for an AQE ID
+     */
+    getAguiId(aqeId) {
+        return this.aqeToAgui.get(aqeId);
+    }
+    /**
+     * Get AQE ID for an AG-UI ID
+     */
+    getAqeId(aguiId) {
+        return this.aguiToAqe.get(aguiId);
+    }
+    /**
+     * Get all ID mappings
+     */
+    getIdMappings() {
+        return [...this.idMappings];
+    }
+    /**
+     * Store bidirectional ID mapping
+     */
+    storeIdMapping(aqeId, aguiId, eventType) {
+        this.aqeToAgui.set(aqeId, aguiId);
+        this.aguiToAqe.set(aguiId, aqeId);
+        this.idMappings.push({
+            aqeId,
+            aguiId,
+            createdAt: this.generateTimestamp(),
+            eventType,
+        });
+    }
+    // ============================================================================
+    // State Accessors
+    // ============================================================================
+    /**
+     * Get current run ID
+     */
+    getCurrentRunId() {
+        return this.currentRunId;
+    }
+    /**
+     * Get active runs
+     */
+    getActiveRuns() {
+        return new Map(this.activeRuns);
+    }
+    /**
+     * Get message state
+     */
+    getMessageState(messageId) {
+        return this.messageStates.get(messageId);
+    }
+    /**
+     * Get all message states
+     */
+    getAllMessageStates() {
+        return new Map(this.messageStates);
+    }
+    /**
+     * Get tool call state
+     */
+    getToolCallState(toolCallId) {
+        return this.toolCallStates.get(toolCallId);
+    }
+    /**
+     * Get all tool call states
+     */
+    getAllToolCallStates() {
+        return new Map(this.toolCallStates);
+    }
+    /**
+     * Get current activities
+     */
+    getActivities() {
+        return [...this.activities];
+    }
+    /**
+     * Get buffered events
+     */
+    getBufferedEvents() {
+        return [...this.eventBuffer];
+    }
+    /**
+     * Clear buffered events
+     */
+    clearBuffer() {
+        this.eventBuffer = [];
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    /**
+     * Reset adapter state
+     */
+    reset() {
+        // Flush any pending batched events before reset
+        if (this.eventBatcher) {
+            this.eventBatcher.flush('manual');
+            this.eventBatcher.resetMetrics();
+        }
+        this.aqeToAgui.clear();
+        this.aguiToAqe.clear();
+        this.idMappings = [];
+        this.activeRuns.clear();
+        this.currentRunId = null;
+        this.messageStates.clear();
+        this.toolCallStates.clear();
+        this.activities = [];
+        this.eventBuffer = [];
+        this.stepProgress.clear();
+    }
+    /**
+     * Generate unique ID
+     */
+    generateId() {
+        return this.config.eventIdGenerator();
+    }
+    /**
+     * Generate event ID
+     */
+    generateEventId() {
+        return `evt_${this.config.eventIdGenerator()}`;
+    }
+    /**
+     * Generate timestamp
+     */
+    generateTimestamp() {
+        return this.config.timestampGenerator();
+    }
+    /**
+     * Create or get current run ID
+     */
+    createOrGetRunId() {
+        if (this.currentRunId) {
+            return this.currentRunId;
+        }
+        const runId = this.generateId();
+        const threadId = this.config.defaultThreadId;
+        const runContext = {
+            runId,
+            threadId,
+            startedAt: this.generateTimestamp(),
+            activeSteps: new Set(),
+            activeMessages: new Set(),
+            activeToolCalls: new Set(),
+        };
+        this.activeRuns.set(runId, runContext);
+        this.currentRunId = runId;
+        return runId;
+    }
+    /**
+     * Get or create message ID for a step
+     */
+    getOrCreateMessageId(stepId) {
+        // Check if we have an active message for this step
+        const entries = Array.from(this.messageStates.entries());
+        for (const [messageId, state] of entries) {
+            if (!state.complete) {
+                return messageId;
+            }
+        }
+        // Create new message
+        const messageId = this.generateId();
+        if (this.config.trackMessageState) {
+            this.messageStates.set(messageId, {
+                messageId,
+                content: '',
+                role: 'assistant',
+                startedAt: this.generateTimestamp(),
+                complete: false,
+            });
+        }
+        return messageId;
+    }
+    /**
+     * Create RAW event for unknown source event
+     */
+    createRawEvent(event) {
+        return {
+            type: 'RAW',
+            eventId: this.generateEventId(),
+            timestamp: this.generateTimestamp(),
+            runId: this.currentRunId ?? undefined,
+            event,
+            source: 'aqe',
+        };
+    }
+    /**
+     * Emit event via EventEmitter (uses batcher if enabled)
+     */
+    emitEvent(event) {
+        if (this.eventBatcher) {
+            // Use batcher - it will handle batching and emit via handleBatchFlush
+            this.eventBatcher.add(event);
+        }
+        else {
+            // Direct emission without batching
+            this.emit('event', event);
+            this.emit(event.type, event);
+        }
+    }
+    /**
+     * Buffer event for streaming
+     */
+    bufferEvent(event) {
+        this.eventBuffer.push(event);
+        // Enforce max buffer size
+        if (this.eventBuffer.length > this.config.maxBufferSize) {
+            this.eventBuffer.shift();
+        }
+    }
+    /**
+     * Validate event structure
+     */
+    validateEvent(event) {
+        if (!event.type) {
+            throw new Error('Event missing required type field');
+        }
+        if (!event.eventId) {
+            throw new Error('Event missing required eventId field');
+        }
+        if (!event.timestamp) {
+            throw new Error('Event missing required timestamp field');
+        }
+    }
+    // ============================================================================
+    // Batcher Operations
+    // ============================================================================
+    /**
+     * Get the event batcher instance (if enabled)
+     */
+    getEventBatcher() {
+        return this.eventBatcher;
+    }
+    /**
+     * Check if event batching is enabled
+     */
+    isBatchingEnabled() {
+        return this.eventBatcher !== null;
+    }
+    /**
+     * Get batcher metrics (if batching is enabled)
+     */
+    getBatcherMetrics() {
+        return this.eventBatcher ? this.eventBatcher.getMetrics() : null;
+    }
+    /**
+     * Manually flush any pending batched events
+     */
+    flushBatcher() {
+        if (this.eventBatcher) {
+            this.eventBatcher.flush('manual');
+        }
+    }
+    /**
+     * Enable or disable event batching at runtime
+     */
+    setBatchingEnabled(enabled) {
+        if (this.eventBatcher) {
+            if (enabled) {
+                this.eventBatcher.enable();
+            }
+            else {
+                this.eventBatcher.disable();
+            }
+        }
+    }
+    /**
+     * Reset batcher metrics
+     */
+    resetBatcherMetrics() {
+        if (this.eventBatcher) {
+            this.eventBatcher.resetMetrics();
+        }
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create a new EventAdapter instance
+ *
+ * @param config - Optional configuration
+ * @returns EventAdapter instance
+ */
+export function createEventAdapter(config = {}) {
+    return new EventAdapter(config);
+}
+//# sourceMappingURL=event-adapter.js.map