@agentlensai/server 0.5.0 → 0.6.0

package/dist/lib/health/computer.js

@@ -0,0 +1,270 @@
+/**
+ * Health Score Computer (Story 1.2)
+ *
+ * Computes health scores for agents based on five dimensions:
+ * error rate, cost efficiency, tool success, latency, and completion rate.
+ * Each dimension is normalized to 0-100 and combined with configurable weights.
+ */
+/** Clamp a value between min and max */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/** Get an ISO date string N days ago from a reference date */
+function daysAgo(days, from = new Date()) {
+    const d = new Date(from);
+    d.setDate(d.getDate() - days);
+    return d.toISOString();
+}
+export class HealthComputer {
+    weights;
+    constructor(weights) {
+        this.weights = weights;
+    }
+    /**
+     * Compute the health score for a single agent within a time window.
+     * Returns null if no sessions exist in the window.
+     */
+    async compute(store, agentId, windowDays) {
+        const now = new Date();
+        const windowFrom = daysAgo(windowDays, now);
+        const windowTo = now.toISOString();
+        // Query sessions in the current window
+        const { sessions } = await store.querySessions({
+            agentId,
+            from: windowFrom,
+            to: windowTo,
+            limit: 10000,
+        });
+        if (sessions.length === 0) {
+            return null;
+        }
+        // Query sessions for the 30-day baseline (excluding current window)
+        const baselineFrom = daysAgo(30, now);
+        const baselineTo = daysAgo(windowDays, now);
+        const { sessions: baselineSessions } = await store.querySessions({
+            agentId,
+            from: baselineFrom,
+            to: baselineTo,
+            limit: 10000,
+        });
+        // Query tool events in the current window
+        const { events: toolEvents } = await store.queryEvents({
+            agentId,
+            from: windowFrom,
+            to: windowTo,
+            eventType: ['tool_call', 'tool_response', 'tool_error'],
+            limit: 10000,
+        });
+        // Compute each dimension
+        const errorRateDim = this.computeErrorRate(sessions);
+        const costEfficiencyDim = this.computeCostEfficiency(sessions, baselineSessions);
+        const toolSuccessDim = this.computeToolSuccess(toolEvents);
+        const latencyDim = this.computeLatency(sessions, baselineSessions);
+        const completionRateDim = this.computeCompletionRate(sessions);
+        const dimensions = [
+            errorRateDim,
+            costEfficiencyDim,
+            toolSuccessDim,
+            latencyDim,
+            completionRateDim,
+        ];
+        const rawOverallScore = errorRateDim.score * this.weights.errorRate +
+            costEfficiencyDim.score * this.weights.costEfficiency +
+            toolSuccessDim.score * this.weights.toolSuccess +
+            latencyDim.score * this.weights.latency +
+            completionRateDim.score * this.weights.completionRate;
+        const overallScore = clamp(rawOverallScore, 0, 100);
+        // Compute trend by comparing against previous window
+        const trend = await this.computeTrend(store, agentId, windowDays, overallScore, now);
+        return {
+            agentId,
+            overallScore: Math.round(overallScore * 100) / 100,
+            trend: trend.direction,
+            trendDelta: trend.delta,
+            dimensions,
+            window: { from: windowFrom, to: windowTo },
+            sessionCount: sessions.length,
+            computedAt: now.toISOString(),
+        };
+    }
+    /**
+     * Compute health scores for all agents in the store.
+     */
+    async computeOverview(store, windowDays) {
+        const agents = await store.listAgents();
+        const results = [];
+        for (const agent of agents) {
+            const score = await this.compute(store, agent.id, windowDays);
+            if (score !== null) {
+                results.push(score);
+            }
+        }
+        return results;
+    }
+    // ─── Dimension Calculations ─────────────────────────────
+    computeErrorRate(sessions) {
+        const total = sessions.length;
+        const withErrors = sessions.filter((s) => s.errorCount > 0).length;
+        const errorRate = total > 0 ? withErrors / total : 0;
+        const score = (1 - errorRate) * 100;
+        return {
+            name: 'error_rate',
+            score: Math.round(score * 100) / 100,
+            weight: this.weights.errorRate,
+            rawValue: Math.round(errorRate * 10000) / 10000,
+            description: `${withErrors}/${total} sessions had errors`,
+        };
+    }
+    computeCostEfficiency(windowSessions, baselineSessions) {
+        const windowTotal = windowSessions.reduce((sum, s) => sum + s.totalCostUsd, 0);
+        const windowAvg = windowSessions.length > 0 ? windowTotal / windowSessions.length : 0;
+        const baselineTotal = baselineSessions.reduce((sum, s) => sum + s.totalCostUsd, 0);
+        const baselineAvg = baselineSessions.length > 0 ? baselineTotal / baselineSessions.length : 0;
+        let score;
+        if (baselineAvg === 0 || windowAvg === 0) {
+            // No cost data or no baseline — neutral score
+            score = 100;
+        }
+        else {
+            const ratio = windowAvg / baselineAvg;
+            score = clamp(100 - (ratio - 1) * 100, 0, 100);
+        }
+        return {
+            name: 'cost_efficiency',
+            score: Math.round(score * 100) / 100,
+            weight: this.weights.costEfficiency,
+            rawValue: Math.round(windowAvg * 1000000) / 1000000,
+            description: `Avg cost per session: $${windowAvg.toFixed(4)}`,
+        };
+    }
+    computeToolSuccess(toolEvents) {
+        // Separate tool_call, tool_response, and tool_error events
+        const toolCalls = toolEvents.filter((e) => e.eventType === 'tool_call');
+        const toolResponses = toolEvents.filter((e) => e.eventType === 'tool_response');
+        const toolErrors = toolEvents.filter((e) => e.eventType === 'tool_error');
+        const totalCalls = toolCalls.length;
+        if (totalCalls === 0) {
+            return {
+                name: 'tool_success',
+                score: 100,
+                weight: this.weights.toolSuccess,
+                rawValue: 1,
+                description: 'No tool calls in window',
+            };
+        }
+        // Count failed tool responses (isError=true in payload) + tool_error events
+        const failedResponses = toolResponses.filter((e) => {
+            const payload = e.payload;
+            return payload.isError === true;
+        }).length;
+        const failedCalls = failedResponses + toolErrors.length;
+        const successRate = (totalCalls - failedCalls) / totalCalls;
+        const score = successRate * 100;
+        return {
+            name: 'tool_success',
+            score: Math.round(score * 100) / 100,
+            weight: this.weights.toolSuccess,
+            rawValue: Math.round(successRate * 10000) / 10000,
+            description: `${totalCalls - failedCalls}/${totalCalls} tool calls succeeded`,
+        };
+    }
+    computeLatency(windowSessions, baselineSessions) {
+        // Compute average duration for sessions with endedAt
+        const windowDurations = windowSessions
+            .filter((s) => s.endedAt)
+            .map((s) => new Date(s.endedAt).getTime() - new Date(s.startedAt).getTime());
+        const avgDuration = windowDurations.length > 0
+            ? windowDurations.reduce((a, b) => a + b, 0) / windowDurations.length
+            : 0;
+        const baselineDurations = baselineSessions
+            .filter((s) => s.endedAt)
+            .map((s) => new Date(s.endedAt).getTime() - new Date(s.startedAt).getTime());
+        const baselineDuration = baselineDurations.length > 0
+            ? baselineDurations.reduce((a, b) => a + b, 0) / baselineDurations.length
+            : 0;
+        let score;
+        if (baselineDuration === 0 || avgDuration === 0) {
+            score = 100;
+        }
+        else {
+            const ratio = avgDuration / baselineDuration;
+            score = clamp(100 - (ratio - 1) * 50, 0, 100);
+        }
+        return {
+            name: 'latency',
+            score: Math.round(score * 100) / 100,
+            weight: this.weights.latency,
+            rawValue: Math.round(avgDuration),
+            description: `Avg session duration: ${Math.round(avgDuration)}ms`,
+        };
+    }
+    computeCompletionRate(sessions) {
+        const total = sessions.length;
+        const completed = sessions.filter((s) => s.status === 'completed').length;
+        const rate = total > 0 ? completed / total : 0;
+        const score = rate * 100;
+        return {
+            name: 'completion_rate',
+            score: Math.round(score * 100) / 100,
+            weight: this.weights.completionRate,
+            rawValue: Math.round(rate * 10000) / 10000,
+            description: `${completed}/${total} sessions completed`,
+        };
+    }
+    // ─── Trend ──────────────────────────────────────────────
+    async computeTrend(store, agentId, windowDays, currentScore, now) {
+        // Previous window: windowDays to 2*windowDays ago
+        const prevFrom = daysAgo(windowDays * 2, now);
+        const prevTo = daysAgo(windowDays, now);
+        const { sessions: prevSessions } = await store.querySessions({
+            agentId,
+            from: prevFrom,
+            to: prevTo,
+            limit: 10000,
+        });
+        if (prevSessions.length === 0) {
+            // No previous data — stable
+            return { direction: 'stable', delta: 0 };
+        }
+        // Query 30-day baseline for previous window
+        const baselineFrom = daysAgo(30, now);
+        const { sessions: baselineSessions } = await store.querySessions({
+            agentId,
+            from: baselineFrom,
+            to: prevTo,
+            limit: 10000,
+        });
+        // Query tool events for previous window
+        const { events: prevToolEvents } = await store.queryEvents({
+            agentId,
+            from: prevFrom,
+            to: prevTo,
+            eventType: ['tool_call', 'tool_response', 'tool_error'],
+            limit: 10000,
+        });
+        // Compute previous window dimensions
+        const prevErrorRate = this.computeErrorRate(prevSessions);
+        const prevCostEff = this.computeCostEfficiency(prevSessions, baselineSessions);
+        const prevToolSuccess = this.computeToolSuccess(prevToolEvents);
+        const prevLatency = this.computeLatency(prevSessions, baselineSessions);
+        const prevCompletion = this.computeCompletionRate(prevSessions);
+        const prevOverall = prevErrorRate.score * this.weights.errorRate +
+            prevCostEff.score * this.weights.costEfficiency +
+            prevToolSuccess.score * this.weights.toolSuccess +
+            prevLatency.score * this.weights.latency +
+            prevCompletion.score * this.weights.completionRate;
+        const delta = Math.round((currentScore - prevOverall) * 100) / 100;
+        let direction;
+        if (delta > 5) {
+            direction = 'improving';
+        }
+        else if (delta < -5) {
+            direction = 'degrading';
+        }
+        else {
+            direction = 'stable';
+        }
+        return { direction, delta };
+    }
+}
+//# sourceMappingURL=computer.js.map

package/dist/lib/health/computer.js.map

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

package/dist/lib/optimization/classifier.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Complexity Classifier (Story 2.2)
+ *
+ * Classifies LLM calls into complexity tiers based on token usage
+ * and tool call count. Used by the optimization engine to group
+ * calls for model-downgrade recommendations.
+ */
+import type { AgentLensEvent, ComplexityTier } from '@agentlensai/core';
+export interface ClassificationSignals {
+    inputTokens: number;
+    outputTokens: number;
+    toolCallCount: number;
+}
+export interface ClassificationResult {
+    tier: ComplexityTier;
+    signals: ClassificationSignals;
+}
+/**
+ * Classify an LLM call's complexity based on token usage and tool calls.
+ *
+ * Thresholds:
+ *   Simple:   <500 input tokens AND 0 tool calls
+ *   Moderate: 500-2000 input tokens OR 1-3 tool calls
+ *   Complex:  >2000 input tokens OR 4+ tool calls
+ *
+ * When both input tokens and tool call count are unknown (null/undefined),
+ * the function defaults to 'moderate' as the safest assumption.
+ *
+ * @param callEvent   - The llm_call event
+ * @param responseEvent - The paired llm_response event (optional)
+ * @returns Classification result with tier and signals used
+ */
+export declare function classifyCallComplexity(callEvent: AgentLensEvent, responseEvent?: AgentLensEvent | null): ClassificationResult;
+//# sourceMappingURL=classifier.d.ts.map

package/dist/lib/optimization/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../../src/lib/optimization/classifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAsC,MAAM,mBAAmB,CAAC;AAE5G,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,qBAAqB,CAAC;CAChC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,cAAc,EACzB,aAAa,CAAC,EAAE,cAAc,GAAG,IAAI,GACpC,oBAAoB,CAkBtB"}

package/dist/lib/optimization/classifier.js

@@ -0,0 +1,108 @@
+/**
+ * Complexity Classifier (Story 2.2)
+ *
+ * Classifies LLM calls into complexity tiers based on token usage
+ * and tool call count. Used by the optimization engine to group
+ * calls for model-downgrade recommendations.
+ */
+/**
+ * Classify an LLM call's complexity based on token usage and tool calls.
+ *
+ * Thresholds:
+ *   Simple:   <500 input tokens AND 0 tool calls
+ *   Moderate: 500-2000 input tokens OR 1-3 tool calls
+ *   Complex:  >2000 input tokens OR 4+ tool calls
+ *
+ * When both input tokens and tool call count are unknown (null/undefined),
+ * the function defaults to 'moderate' as the safest assumption.
+ *
+ * @param callEvent   - The llm_call event
+ * @param responseEvent - The paired llm_response event (optional)
+ * @returns Classification result with tier and signals used
+ */
+export function classifyCallComplexity(callEvent, responseEvent) {
+    const callPayload = callEvent.payload;
+    const responsePayload = responseEvent?.payload;
+    // Extract signals from whichever source is available
+    const inputTokens = extractInputTokens(callPayload, responsePayload);
+    const outputTokens = extractOutputTokens(responsePayload);
+    const toolCallCount = extractToolCallCount(callPayload, responsePayload);
+    const signals = {
+        inputTokens: inputTokens ?? 0,
+        outputTokens: outputTokens ?? 0,
+        toolCallCount: toolCallCount ?? 0,
+    };
+    const tier = determineTier(inputTokens, toolCallCount);
+    return { tier, signals };
+}
+/**
+ * Extract input token count from call or response payload.
+ * Returns null if unavailable from either source.
+ */
+function extractInputTokens(callPayload, responsePayload) {
+    // Prefer response usage (actual) over call usage (estimated)
+    const fromResponse = responsePayload?.usage?.inputTokens;
+    if (fromResponse != null && fromResponse >= 0)
+        return fromResponse;
+    // Some implementations attach usage directly on the call payload
+    const callWithUsage = callPayload;
+    const usage = callWithUsage.usage;
+    if (usage?.inputTokens != null && usage.inputTokens >= 0)
+        return usage.inputTokens;
+    return null;
+}
+/**
+ * Extract output token count from response payload.
+ */
+function extractOutputTokens(responsePayload) {
+    const fromResponse = responsePayload?.usage?.outputTokens;
+    if (fromResponse != null && fromResponse >= 0)
+        return fromResponse;
+    return null;
+}
+/**
+ * Extract tool call count.
+ * Checks: call payload's tools (definitions provided), then response payload's
+ * toolCalls (actual invocations). Uses whichever is available.
+ */
+function extractToolCallCount(callPayload, responsePayload) {
+    // Response toolCalls = actual tool invocations (preferred)
+    if (responsePayload?.toolCalls != null) {
+        return responsePayload.toolCalls.length;
+    }
+    // No actual tool calls in response — default to 0
+    // (Don't fall back to tools definitions count, which is available tools, not invocations)
+    return 0;
+}
+/**
+ * Determine tier from extracted signals.
+ * If both inputs are null, defaults to 'moderate' (safe fallback).
+ */
+function determineTier(inputTokens, toolCallCount) {
+    const tokensKnown = inputTokens != null;
+    const toolsKnown = toolCallCount != null;
+    // If we have no data at all, default to moderate
+    if (!tokensKnown && !toolsKnown) {
+        return 'moderate';
+    }
+    // Check complex thresholds first (most restrictive)
+    if (tokensKnown && inputTokens > 2000)
+        return 'complex';
+    if (toolsKnown && toolCallCount >= 4)
+        return 'complex';
+    // Check simple thresholds (requires BOTH conditions)
+    if (tokensKnown && inputTokens < 500 && toolsKnown && toolCallCount === 0) {
+        return 'simple';
+    }
+    // If only tokens known and <500 with no tool info → can't confirm simple
+    if (tokensKnown && inputTokens < 500 && !toolsKnown) {
+        return 'moderate';
+    }
+    // If only tools known and 0 with no token info → can't confirm simple
+    if (!tokensKnown && toolsKnown && toolCallCount === 0) {
+        return 'moderate';
+    }
+    // Everything else is moderate
+    return 'moderate';
+}
+//# sourceMappingURL=classifier.js.map

package/dist/lib/optimization/classifier.js.map

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

package/dist/lib/optimization/engine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Recommendation Engine (Story 2.3)
+ *
+ * Analyzes LLM call patterns and recommends cheaper models for
+ * each complexity tier where a cheaper alternative has proven
+ * reliable (≥95% success rate).
+ */
+import type { IEventStore, OptimizationResult, ModelCosts } from '@agentlensai/core';
+export declare class OptimizationEngine {
+    private readonly modelCosts;
+    constructor(modelCosts?: ModelCosts);
+    getRecommendations(store: IEventStore, options: {
+        agentId?: string;
+        period: number;
+        limit: number;
+    }): Promise<OptimizationResult>;
+    /**
+     * Get the weighted cost rate for a model (per 1M tokens).
+     * Uses known model costs table, or falls back to actual cost data from events.
+     */
+    private getModelCostRate;
+    private determineConfidence;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/lib/optimization/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/lib/optimization/engine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,WAAW,EAGX,kBAAkB,EAClB,UAAU,EAKX,MAAM,mBAAmB,CAAC;AAgB3B,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,GAAE,UAAgC;IAGzD,kBAAkB,CACtB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,GACA,OAAO,CAAC,kBAAkB,CAAC;IAgL9B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAwBxB,OAAO,CAAC,mBAAmB;CAK5B"}

package/dist/lib/optimization/engine.js

@@ -0,0 +1,202 @@
+/**
+ * Recommendation Engine (Story 2.3)
+ *
+ * Analyzes LLM call patterns and recommends cheaper models for
+ * each complexity tier where a cheaper alternative has proven
+ * reliable (≥95% success rate).
+ */
+import { DEFAULT_MODEL_COSTS } from '@agentlensai/core';
+import { classifyCallComplexity } from './classifier.js';
+export class OptimizationEngine {
+    modelCosts;
+    constructor(modelCosts = DEFAULT_MODEL_COSTS) {
+        this.modelCosts = modelCosts;
+    }
+    async getRecommendations(store, options) {
+        const { agentId, period, limit } = options;
+        // Compute date range
+        const now = new Date();
+        const from = new Date(now.getTime() - period * 24 * 60 * 60 * 1000).toISOString();
+        const to = now.toISOString();
+        // 1. Query llm_call events for the period
+        const callResult = await store.queryEvents({
+            eventType: 'llm_call',
+            agentId,
+            from,
+            to,
+            limit: 10_000,
+            order: 'asc',
+        });
+        const callEvents = callResult.events;
+        if (callEvents.length === 0) {
+            return {
+                recommendations: [],
+                totalPotentialSavings: 0,
+                period,
+                analyzedCalls: 0,
+            };
+        }
+        // 2. Query llm_response events for pairing
+        const responseResult = await store.queryEvents({
+            eventType: 'llm_response',
+            agentId,
+            from,
+            to,
+            limit: 10_000,
+            order: 'asc',
+        });
+        // Build response lookup by callId
+        const responseMap = new Map();
+        for (const evt of responseResult.events) {
+            const payload = evt.payload;
+            if (payload.callId) {
+                responseMap.set(payload.callId, evt);
+            }
+        }
+        // 3. Classify each call and group by (model, tier)
+        const groups = new Map();
+        for (const callEvent of callEvents) {
+            const callPayload = callEvent.payload;
+            const callId = callPayload.callId;
+            const model = callPayload.model;
+            if (!model)
+                continue;
+            const responseEvent = callId ? responseMap.get(callId) ?? null : null;
+            const responsePayload = responseEvent?.payload;
+            // Skip unmatched calls (no response yet) — don't count them as failures
+            if (!responseEvent)
+                continue;
+            const { tier } = classifyCallComplexity(callEvent, responseEvent);
+            const groupKey = `${model}::${tier}`;
+            let group = groups.get(groupKey);
+            if (!group) {
+                group = {
+                    model,
+                    tier,
+                    callCount: 0,
+                    successCount: 0,
+                    totalCost: 0,
+                    totalInputTokens: 0,
+                    totalOutputTokens: 0,
+                    agentIds: new Set(),
+                };
+                groups.set(groupKey, group);
+            }
+            group.callCount++;
+            group.agentIds.add(callEvent.agentId);
+            // Determine success: finishReason is not 'error'
+            const isError = responsePayload?.finishReason === 'error';
+            if (!isError) {
+                group.successCount++;
+            }
+            // Accumulate cost from response payload
+            const cost = responsePayload?.costUsd ?? 0;
+            group.totalCost += cost;
+            // Accumulate tokens
+            const inputTokens = responsePayload?.usage?.inputTokens ?? 0;
+            const outputTokens = responsePayload?.usage?.outputTokens ?? 0;
+            group.totalInputTokens += inputTokens;
+            group.totalOutputTokens += outputTokens;
+        }
+        // 4. For each group, look for cheaper alternatives
+        const recommendations = [];
+        for (const [, group] of groups) {
+            const currentCostPerCall = group.callCount > 0 ? group.totalCost / group.callCount : 0;
+            const currentSuccessRate = group.callCount > 0 ? group.successCount / group.callCount : 0;
+            // Get effective cost rate for this model
+            const currentModelCost = this.getModelCostRate(group);
+            if (currentModelCost === null)
+                continue;
+            // Find cheaper alternatives that have data at this tier
+            for (const [, candidateGroup] of groups) {
+                if (candidateGroup.model === group.model)
+                    continue;
+                if (candidateGroup.tier !== group.tier)
+                    continue;
+                const candidateCostRate = this.getModelCostRate(candidateGroup);
+                if (candidateCostRate === null)
+                    continue;
+                // Must be cheaper
+                if (candidateCostRate >= currentModelCost)
+                    continue;
+                // Must have ≥95% success rate
+                const candidateSuccessRate = candidateGroup.callCount > 0
+                    ? candidateGroup.successCount / candidateGroup.callCount
+                    : 0;
+                if (candidateSuccessRate < 0.95)
+                    continue;
+                const recommendedCostPerCall = candidateGroup.callCount > 0
+                    ? candidateGroup.totalCost / candidateGroup.callCount
+                    : 0;
+                const monthlySavings = (currentCostPerCall - recommendedCostPerCall) * group.callCount * (30 / period);
+                if (monthlySavings <= 0)
+                    continue;
+                const confidence = this.determineConfidence(group.callCount);
+                // Pick a representative agentId (first in set)
+                const agentId = group.agentIds.values().next().value ?? '';
+                recommendations.push({
+                    currentModel: group.model,
+                    recommendedModel: candidateGroup.model,
+                    complexityTier: group.tier,
+                    currentCostPerCall: roundCost(currentCostPerCall),
+                    recommendedCostPerCall: roundCost(recommendedCostPerCall),
+                    monthlySavings: roundCost(monthlySavings),
+                    callVolume: group.callCount,
+                    currentSuccessRate: roundRate(currentSuccessRate),
+                    recommendedSuccessRate: roundRate(candidateSuccessRate),
+                    confidence,
+                    agentId,
+                });
+            }
+        }
+        // 5. Sort by monthlySavings DESC, take top N
+        recommendations.sort((a, b) => b.monthlySavings - a.monthlySavings);
+        const limited = recommendations.slice(0, limit);
+        const totalPotentialSavings = limited.reduce((sum, r) => sum + r.monthlySavings, 0);
+        return {
+            recommendations: limited,
+            totalPotentialSavings: roundCost(totalPotentialSavings),
+            period,
+            analyzedCalls: callEvents.length,
+        };
+    }
+    /**
+     * Get the weighted cost rate for a model (per 1M tokens).
+     * Uses known model costs table, or falls back to actual cost data from events.
+     */
+    getModelCostRate(group) {
+        const knownCost = this.modelCosts[group.model];
+        if (knownCost) {
+            // Weighted average using actual input/output ratio when available
+            const totalTokens = group.totalInputTokens + group.totalOutputTokens;
+            let inputWeight = 0.75; // default fallback ~3:1 input:output
+            let outputWeight = 0.25;
+            if (totalTokens > 0) {
+                inputWeight = group.totalInputTokens / totalTokens;
+                outputWeight = group.totalOutputTokens / totalTokens;
+            }
+            return knownCost.input * inputWeight + knownCost.output * outputWeight;
+        }
+        // Fall back to actual cost from event data
+        const totalTokens = group.totalInputTokens + group.totalOutputTokens;
+        if (totalTokens > 0 && group.totalCost > 0) {
+            // Effective cost per 1M tokens from actual data
+            return (group.totalCost / totalTokens) * 1_000_000;
+        }
+        return null;
+    }
+    determineConfidence(callVolume) {
+        if (callVolume > 200)
+            return 'high';
+        if (callVolume >= 50)
+            return 'medium';
+        return 'low';
+    }
+}
+function roundCost(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+function roundRate(value) {
+    return Math.round(value * 10_000) / 10_000;
+}
+//# sourceMappingURL=engine.js.map