@revealui/ai 0.1.0

package/dist/observability/metrics.js

@@ -0,0 +1,197 @@
+/**
+ * @revealui/ai - Agent Metrics Collector
+ *
+ * Aggregates statistics from agent events for monitoring and analysis.
+ */
+/**
+ * Agent metrics collector
+ */
+export class AgentMetricsCollector {
+    logger;
+    startTime;
+    constructor(logger) {
+        this.logger = logger;
+        this.startTime = Date.now();
+    }
+    /**
+     * Get metrics for a specific agent
+     */
+    getMetrics(agentId) {
+        const filter = { agentId };
+        const events = this.logger.getEvents(filter);
+        const decisions = events.filter((e) => e.eventType === 'decision');
+        const toolCalls = events.filter((e) => e.eventType === 'tool_call');
+        const llmCalls = events.filter((e) => e.eventType === 'llm_call');
+        const errors = events.filter((e) => e.eventType === 'error');
+        const totalDecisions = decisions.length;
+        const totalToolCalls = toolCalls.length;
+        const totalLLMCalls = llmCalls.length;
+        const totalErrors = errors.length;
+        // Calculate average decision time (time between decisions)
+        let averageDecisionTime = 0;
+        if (decisions.length > 1) {
+            const times = decisions.map((d) => d.timestamp).sort((a, b) => a - b);
+            const intervals = [];
+            for (let i = 1; i < times.length; i++) {
+                const current = times[i];
+                const previous = times[i - 1];
+                if (current !== undefined && previous !== undefined) {
+                    intervals.push(current - previous);
+                }
+            }
+            averageDecisionTime = intervals.reduce((sum, val) => sum + val, 0) / intervals.length;
+        }
+        // Calculate success rate
+        const successfulCalls = toolCalls.filter((t) => t.eventType === 'tool_call' && t.success).length;
+        const successRate = totalToolCalls > 0 ? (successfulCalls / totalToolCalls) * 100 : 0;
+        // Calculate error rate
+        const totalOperations = totalDecisions + totalToolCalls + totalLLMCalls;
+        const errorRate = totalOperations > 0 ? (totalErrors / totalOperations) * 100 : 0;
+        // Build tool metrics
+        const toolMetrics = this.calculateToolMetrics(toolCalls);
+        // Build LLM metrics
+        const llmMetrics = this.calculateLLMMetrics(llmCalls);
+        // Calculate uptime and last activity
+        const uptime = Date.now() - this.startTime;
+        const lastActivity = events.length > 0 ? Math.max(...events.map((e) => e.timestamp)) : this.startTime;
+        return {
+            totalDecisions,
+            totalToolCalls,
+            totalLLMCalls,
+            totalErrors,
+            averageDecisionTime,
+            successRate,
+            errorRate,
+            toolMetrics,
+            llmMetrics,
+            uptime,
+            lastActivity,
+        };
+    }
+    /**
+     * Calculate tool-specific metrics
+     */
+    calculateToolMetrics(toolCalls) {
+        const metrics = new Map();
+        for (const event of toolCalls) {
+            if (event.eventType !== 'tool_call')
+                continue;
+            const existing = metrics.get(event.toolName);
+            const success = event.success ? 1 : 0;
+            const failure = event.success ? 0 : 1;
+            if (existing) {
+                metrics.set(event.toolName, {
+                    totalCalls: existing.totalCalls + 1,
+                    successCount: existing.successCount + success,
+                    failureCount: existing.failureCount + failure,
+                    averageDurationMs: (existing.averageDurationMs * existing.totalCalls + event.durationMs) /
+                        (existing.totalCalls + 1),
+                    lastUsed: Math.max(existing.lastUsed, event.timestamp),
+                });
+            }
+            else {
+                metrics.set(event.toolName, {
+                    totalCalls: 1,
+                    successCount: success,
+                    failureCount: failure,
+                    averageDurationMs: event.durationMs,
+                    lastUsed: event.timestamp,
+                });
+            }
+        }
+        return metrics;
+    }
+    /**
+     * Calculate LLM-specific metrics
+     */
+    calculateLLMMetrics(llmCalls) {
+        let totalCalls = 0;
+        let totalPromptTokens = 0;
+        let totalCompletionTokens = 0;
+        let totalCost = 0;
+        let totalDuration = 0;
+        let cacheHits = 0;
+        const modelUsage = {};
+        for (const event of llmCalls) {
+            if (event.eventType !== 'llm_call')
+                continue;
+            totalCalls++;
+            totalPromptTokens += event.promptTokens;
+            totalCompletionTokens += event.completionTokens;
+            totalCost += event.cost ?? 0;
+            totalDuration += event.durationMs;
+            if (event.cacheHit) {
+                cacheHits++;
+            }
+            const modelKey = `${event.provider}/${event.model}`;
+            modelUsage[modelKey] = (modelUsage[modelKey] ?? 0) + 1;
+        }
+        return {
+            totalCalls,
+            totalPromptTokens,
+            totalCompletionTokens,
+            totalCost,
+            averageDurationMs: totalCalls > 0 ? totalDuration / totalCalls : 0,
+            cacheHitRate: totalCalls > 0 ? (cacheHits / totalCalls) * 100 : 0,
+            modelUsage,
+        };
+    }
+    /**
+     * Get summary metrics across all agents
+     */
+    getMetricsSummary(filter) {
+        const events = this.logger.getEvents(filter);
+        const eventsByType = {};
+        const agentIds = new Set();
+        const sessionIds = new Set();
+        let totalTokensUsed = 0;
+        let totalCost = 0;
+        let successfulToolCalls = 0;
+        let totalToolCalls = 0;
+        for (const event of events) {
+            eventsByType[event.eventType] = (eventsByType[event.eventType] ?? 0) + 1;
+            agentIds.add(event.agentId);
+            sessionIds.add(event.sessionId);
+            if (event.eventType === 'llm_call') {
+                totalTokensUsed += event.promptTokens + event.completionTokens;
+                totalCost += event.cost ?? 0;
+            }
+            if (event.eventType === 'tool_call') {
+                totalToolCalls++;
+                if (event.success) {
+                    successfulToolCalls++;
+                }
+            }
+        }
+        const timestamps = events.map((e) => e.timestamp);
+        const start = timestamps.length > 0 ? Math.min(...timestamps) : Date.now();
+        const end = timestamps.length > 0 ? Math.max(...timestamps) : Date.now();
+        return {
+            totalEvents: events.length,
+            eventsByType,
+            activeAgents: agentIds.size,
+            activeSessions: sessionIds.size,
+            totalTokensUsed,
+            totalCost,
+            averageSuccessRate: totalToolCalls > 0 ? (successfulToolCalls / totalToolCalls) * 100 : 0,
+            timeRange: { start, end },
+        };
+    }
+    /**
+     * Get tool usage statistics
+     */
+    getToolUsageStats() {
+        const toolCalls = this.logger.getToolCalls();
+        const metrics = this.calculateToolMetrics(toolCalls);
+        return Array.from(metrics.entries())
+            .map(([toolName, metrics]) => ({ toolName, metrics }))
+            .sort((a, b) => b.metrics.totalCalls - a.metrics.totalCalls);
+    }
+    /**
+     * Get LLM usage statistics
+     */
+    getLLMUsageStats() {
+        const llmCalls = this.logger.getLLMCalls();
+        return this.calculateLLMMetrics(llmCalls);
+    }
+}

package/dist/observability/query.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @revealui/ai - Query Interface
+ *
+ * Advanced querying capabilities for agent events.
+ */
+import type { AgentEventLogger } from './logger.js';
+import type { AnyAgentEvent, DecisionEvent, ErrorEvent, EventFilter, LLMCallEvent, MetricsSummary, ToolCallEvent } from './types.js';
+export declare class AgentEventQuery {
+    private logger;
+    constructor(logger: AgentEventLogger);
+    /**
+     * Get events in a specific time range
+     */
+    getEventsInRange(start: Date, end: Date): AnyAgentEvent[];
+    /**
+     * Get events from the last N milliseconds
+     */
+    getRecentEvents(milliseconds: number, count?: number): AnyAgentEvent[];
+    /**
+     * Get events from the last N minutes
+     */
+    getEventsLastMinutes(minutes: number): AnyAgentEvent[];
+    /**
+     * Get events from the last N hours
+     */
+    getEventsLastHours(hours: number): AnyAgentEvent[];
+    /**
+     * Get events from today
+     */
+    getEventsToday(): AnyAgentEvent[];
+    /**
+     * Get all events for a specific agent
+     */
+    getEventsForAgent(agentId: string): AnyAgentEvent[];
+    /**
+     * Get all events for a specific session
+     */
+    getEventsForSession(sessionId: string): AnyAgentEvent[];
+    /**
+     * Get all events for a specific task
+     */
+    getEventsForTask(taskId: string): AnyAgentEvent[];
+    /**
+     * Get all events for multiple agents
+     */
+    getEventsForAgents(agentIds: string[]): AnyAgentEvent[];
+    /**
+     * Get all decision events
+     */
+    getDecisions(filter?: Omit<EventFilter, 'eventType'>): DecisionEvent[];
+    /**
+     * Get all tool call events
+     */
+    getToolCalls(filter?: Omit<EventFilter, 'eventType'>): ToolCallEvent[];
+    /**
+     * Get all LLM call events
+     */
+    getLLMCalls(filter?: Omit<EventFilter, 'eventType'>): LLMCallEvent[];
+    /**
+     * Get all error events
+     */
+    getErrors(filter?: Omit<EventFilter, 'eventType'>): ErrorEvent[];
+    /**
+     * Get successful tool calls
+     */
+    getSuccessfulToolCalls(filter?: Omit<EventFilter, 'eventType'>): ToolCallEvent[];
+    /**
+     * Get failed tool calls
+     */
+    getFailedToolCalls(filter?: Omit<EventFilter, 'eventType'>): ToolCallEvent[];
+    /**
+     * Get tool calls for a specific tool
+     */
+    getToolCallsForTool(toolName: string, filter?: Omit<EventFilter, 'eventType'>): ToolCallEvent[];
+    /**
+     * Get LLM calls for a specific provider
+     */
+    getLLMCallsForProvider(provider: string, filter?: Omit<EventFilter, 'eventType'>): LLMCallEvent[];
+    /**
+     * Get LLM calls for a specific model
+     */
+    getLLMCallsForModel(model: string, filter?: Omit<EventFilter, 'eventType'>): LLMCallEvent[];
+    /**
+     * Get recoverable errors
+     */
+    getRecoverableErrors(filter?: Omit<EventFilter, 'eventType'>): ErrorEvent[];
+    /**
+     * Get non-recoverable errors
+     */
+    getNonRecoverableErrors(filter?: Omit<EventFilter, 'eventType'>): ErrorEvent[];
+    /**
+     * Get event count by type
+     */
+    getEventCountByType(filter?: EventFilter): Record<string, number>;
+    /**
+     * Get unique agent IDs
+     */
+    getUniqueAgentIds(filter?: EventFilter): string[];
+    /**
+     * Get unique session IDs
+     */
+    getUniqueSessionIds(filter?: EventFilter): string[];
+    /**
+     * Get total token usage
+     */
+    getTotalTokenUsage(filter?: Omit<EventFilter, 'eventType'>): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /**
+     * Get total LLM cost
+     */
+    getTotalLLMCost(filter?: Omit<EventFilter, 'eventType'>): number;
+    /**
+     * Get average tool call duration
+     */
+    getAverageToolCallDuration(filter?: Omit<EventFilter, 'eventType'>): number;
+    /**
+     * Get average LLM call duration
+     */
+    getAverageLLMCallDuration(filter?: Omit<EventFilter, 'eventType'>): number;
+    /**
+     * Get success rate
+     */
+    getSuccessRate(filter?: Omit<EventFilter, 'eventType'>): number;
+    /**
+     * Get metrics summary
+     */
+    getMetricsSummary(filter?: EventFilter): MetricsSummary;
+    /**
+     * Search events by text in reasoning or error messages
+     */
+    searchEvents(searchText: string, filter?: EventFilter): AnyAgentEvent[];
+    /**
+     * Get events sorted by timestamp (ascending or descending)
+     */
+    getSortedEvents(filter?: EventFilter, order?: 'asc' | 'desc'): AnyAgentEvent[];
+    /**
+     * Paginate events
+     */
+    paginateEvents(page: number, pageSize: number, filter?: EventFilter): {
+        events: AnyAgentEvent[];
+        page: number;
+        pageSize: number;
+        totalPages: number;
+        totalEvents: number;
+    };
+}
+//# sourceMappingURL=query.d.ts.map

package/dist/observability/query.d.ts.map

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

package/dist/observability/query.js

@@ -0,0 +1,339 @@
+/**
+ * @revealui/ai - Query Interface
+ *
+ * Advanced querying capabilities for agent events.
+ */
+export class AgentEventQuery {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    // =========================================================================
+    // Time-based queries
+    // =========================================================================
+    /**
+     * Get events in a specific time range
+     */
+    getEventsInRange(start, end) {
+        return this.logger.getEvents({
+            startTime: start.getTime(),
+            endTime: end.getTime(),
+        });
+    }
+    /**
+     * Get events from the last N milliseconds
+     */
+    getRecentEvents(milliseconds, count) {
+        const events = this.logger.getEvents({
+            startTime: Date.now() - milliseconds,
+        });
+        return count ? events.slice(-count) : events;
+    }
+    /**
+     * Get events from the last N minutes
+     */
+    getEventsLastMinutes(minutes) {
+        return this.getRecentEvents(minutes * 60 * 1000);
+    }
+    /**
+     * Get events from the last N hours
+     */
+    getEventsLastHours(hours) {
+        return this.getRecentEvents(hours * 60 * 60 * 1000);
+    }
+    /**
+     * Get events from today
+     */
+    getEventsToday() {
+        const now = new Date();
+        const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        return this.getEventsInRange(startOfDay, now);
+    }
+    // =========================================================================
+    // Entity-based queries
+    // =========================================================================
+    /**
+     * Get all events for a specific agent
+     */
+    getEventsForAgent(agentId) {
+        return this.logger.getEvents({ agentId });
+    }
+    /**
+     * Get all events for a specific session
+     */
+    getEventsForSession(sessionId) {
+        return this.logger.getEvents({ sessionId });
+    }
+    /**
+     * Get all events for a specific task
+     */
+    getEventsForTask(taskId) {
+        return this.logger.getEvents({ taskId });
+    }
+    /**
+     * Get all events for multiple agents
+     */
+    getEventsForAgents(agentIds) {
+        const events = [];
+        for (const agentId of agentIds) {
+            events.push(...this.getEventsForAgent(agentId));
+        }
+        return events.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    // =========================================================================
+    // Type-based queries
+    // =========================================================================
+    /**
+     * Get all decision events
+     */
+    getDecisions(filter) {
+        return this.logger.getEvents({
+            ...filter,
+            eventType: 'decision',
+        });
+    }
+    /**
+     * Get all tool call events
+     */
+    getToolCalls(filter) {
+        return this.logger.getEvents({
+            ...filter,
+            eventType: 'tool_call',
+        });
+    }
+    /**
+     * Get all LLM call events
+     */
+    getLLMCalls(filter) {
+        return this.logger.getEvents({
+            ...filter,
+            eventType: 'llm_call',
+        });
+    }
+    /**
+     * Get all error events
+     */
+    getErrors(filter) {
+        return this.logger.getEvents({
+            ...filter,
+            eventType: 'error',
+        });
+    }
+    // =========================================================================
+    // Advanced queries
+    // =========================================================================
+    /**
+     * Get successful tool calls
+     */
+    getSuccessfulToolCalls(filter) {
+        const toolCalls = this.getToolCalls(filter);
+        return toolCalls.filter((call) => call.success);
+    }
+    /**
+     * Get failed tool calls
+     */
+    getFailedToolCalls(filter) {
+        const toolCalls = this.getToolCalls(filter);
+        return toolCalls.filter((call) => !call.success);
+    }
+    /**
+     * Get tool calls for a specific tool
+     */
+    getToolCallsForTool(toolName, filter) {
+        const toolCalls = this.getToolCalls(filter);
+        return toolCalls.filter((call) => call.toolName === toolName);
+    }
+    /**
+     * Get LLM calls for a specific provider
+     */
+    getLLMCallsForProvider(provider, filter) {
+        const llmCalls = this.getLLMCalls(filter);
+        return llmCalls.filter((call) => call.provider === provider);
+    }
+    /**
+     * Get LLM calls for a specific model
+     */
+    getLLMCallsForModel(model, filter) {
+        const llmCalls = this.getLLMCalls(filter);
+        return llmCalls.filter((call) => call.model === model);
+    }
+    /**
+     * Get recoverable errors
+     */
+    getRecoverableErrors(filter) {
+        const errors = this.getErrors(filter);
+        return errors.filter((error) => error.recoverable);
+    }
+    /**
+     * Get non-recoverable errors
+     */
+    getNonRecoverableErrors(filter) {
+        const errors = this.getErrors(filter);
+        return errors.filter((error) => !error.recoverable);
+    }
+    // =========================================================================
+    // Aggregations
+    // =========================================================================
+    /**
+     * Get event count by type
+     */
+    getEventCountByType(filter) {
+        const events = this.logger.getEvents(filter);
+        const counts = {};
+        for (const event of events) {
+            counts[event.eventType] = (counts[event.eventType] || 0) + 1;
+        }
+        return counts;
+    }
+    /**
+     * Get unique agent IDs
+     */
+    getUniqueAgentIds(filter) {
+        const events = this.logger.getEvents(filter);
+        const agentIds = new Set();
+        for (const event of events) {
+            agentIds.add(event.agentId);
+        }
+        return Array.from(agentIds);
+    }
+    /**
+     * Get unique session IDs
+     */
+    getUniqueSessionIds(filter) {
+        const events = this.logger.getEvents(filter);
+        const sessionIds = new Set();
+        for (const event of events) {
+            sessionIds.add(event.sessionId);
+        }
+        return Array.from(sessionIds);
+    }
+    /**
+     * Get total token usage
+     */
+    getTotalTokenUsage(filter) {
+        const llmCalls = this.getLLMCalls(filter);
+        let promptTokens = 0;
+        let completionTokens = 0;
+        for (const call of llmCalls) {
+            promptTokens += call.promptTokens;
+            completionTokens += call.completionTokens;
+        }
+        return {
+            promptTokens,
+            completionTokens,
+            totalTokens: promptTokens + completionTokens,
+        };
+    }
+    /**
+     * Get total LLM cost
+     */
+    getTotalLLMCost(filter) {
+        const llmCalls = this.getLLMCalls(filter);
+        return llmCalls.reduce((total, call) => total + (call.cost || 0), 0);
+    }
+    /**
+     * Get average tool call duration
+     */
+    getAverageToolCallDuration(filter) {
+        const toolCalls = this.getToolCalls(filter);
+        if (toolCalls.length === 0) {
+            return 0;
+        }
+        const totalDuration = toolCalls.reduce((sum, call) => sum + call.durationMs, 0);
+        return totalDuration / toolCalls.length;
+    }
+    /**
+     * Get average LLM call duration
+     */
+    getAverageLLMCallDuration(filter) {
+        const llmCalls = this.getLLMCalls(filter);
+        if (llmCalls.length === 0) {
+            return 0;
+        }
+        const totalDuration = llmCalls.reduce((sum, call) => sum + call.durationMs, 0);
+        return totalDuration / llmCalls.length;
+    }
+    /**
+     * Get success rate
+     */
+    getSuccessRate(filter) {
+        const toolCalls = this.getToolCalls(filter);
+        if (toolCalls.length === 0) {
+            return 0;
+        }
+        const successful = toolCalls.filter((call) => call.success).length;
+        return (successful / toolCalls.length) * 100;
+    }
+    /**
+     * Get metrics summary
+     */
+    getMetricsSummary(filter) {
+        const events = this.logger.getEvents(filter);
+        const eventsByType = this.getEventCountByType(filter);
+        const agentIds = this.getUniqueAgentIds(filter);
+        const sessionIds = this.getUniqueSessionIds(filter);
+        const tokenUsage = this.getTotalTokenUsage(filter);
+        const totalCost = this.getTotalLLMCost(filter);
+        const successRate = this.getSuccessRate(filter);
+        const timestamps = events.map((e) => e.timestamp);
+        const start = timestamps.length > 0 ? Math.min(...timestamps) : Date.now();
+        const end = timestamps.length > 0 ? Math.max(...timestamps) : Date.now();
+        return {
+            totalEvents: events.length,
+            eventsByType,
+            activeAgents: agentIds.length,
+            activeSessions: sessionIds.length,
+            totalTokensUsed: tokenUsage.totalTokens,
+            totalCost,
+            averageSuccessRate: successRate,
+            timeRange: { start, end },
+        };
+    }
+    // =========================================================================
+    // Search and filter
+    // =========================================================================
+    /**
+     * Search events by text in reasoning or error messages
+     */
+    searchEvents(searchText, filter) {
+        const events = this.logger.getEvents(filter);
+        const lowerSearch = searchText.toLowerCase();
+        return events.filter((event) => {
+            if (event.eventType === 'decision') {
+                return event.reasoning.toLowerCase().includes(lowerSearch);
+            }
+            if (event.eventType === 'error') {
+                return event.message.toLowerCase().includes(lowerSearch);
+            }
+            if (event.eventType === 'tool_call') {
+                return event.toolName.toLowerCase().includes(lowerSearch);
+            }
+            return false;
+        });
+    }
+    /**
+     * Get events sorted by timestamp (ascending or descending)
+     */
+    getSortedEvents(filter, order = 'asc') {
+        const events = this.logger.getEvents(filter);
+        return events.sort((a, b) => order === 'asc' ? a.timestamp - b.timestamp : b.timestamp - a.timestamp);
+    }
+    /**
+     * Paginate events
+     */
+    paginateEvents(page, pageSize, filter) {
+        const allEvents = this.getSortedEvents(filter, 'desc');
+        const totalEvents = allEvents.length;
+        const totalPages = Math.ceil(totalEvents / pageSize);
+        const start = (page - 1) * pageSize;
+        const end = start + pageSize;
+        const events = allEvents.slice(start, end);
+        return {
+            events,
+            page,
+            pageSize,
+            totalPages,
+            totalEvents,
+        };
+    }
+}