@agent-finops/core 0.7.3 → 0.8.1

package/dist/modelPricing.js

@@ -7,10 +7,13 @@
  * matched top-down; first match wins. Unknown models return undefined so
  * callers can label the record "missing" instead of inventing a number.
  */
-export const PRICING_TABLE_AS_OF = "2026-07-28";
+export const PRICING_TABLE_AS_OF = "2026-08-14";
 const pricingRules = [
     // Anthropic
     { match: /^claude-fable-5/i, inputPerM: 10, outputPerM: 50 },
+    { match: /^claude-mythos-5/i, inputPerM: 10, outputPerM: 50 },
+    { match: /^claude-opus-5/i, inputPerM: 5, outputPerM: 25 },
+    { match: /^claude-sonnet-5/i, inputPerM: 2, outputPerM: 10 },
     { match: /^claude-opus-4-[5-9]/i, inputPerM: 5, outputPerM: 25 },
     { match: /^claude-opus-4(-[01])?$/i, inputPerM: 15, outputPerM: 75 },
     { match: /^claude-sonnet-4/i, inputPerM: 3, outputPerM: 15 },
@@ -18,9 +21,42 @@ const pricingRules = [
     { match: /^claude-3-7-sonnet|^claude-3-5-sonnet/i, inputPerM: 3, outputPerM: 15 },
     { match: /^claude-3-5-haiku/i, inputPerM: 0.8, outputPerM: 4 },
     // OpenAI (newer and more specific families must precede the GPT-5 fallback)
-    { match: /^gpt-5\.6(?:-sol)?$/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
-    { match: /^gpt-5\.6-terra/i, inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 },
-    { match: /^gpt-5\.6-luna/i, inputPerM: 1, outputPerM: 6, cacheReadPerM: 0.1 },
+    {
+        match: /^gpt-5\.6(?:-sol)?$/i,
+        inputPerM: 5,
+        outputPerM: 30,
+        cacheReadPerM: 0.5,
+        abovePromptTokens: {
+            threshold: 272_000,
+            inputPerM: 10,
+            outputPerM: 45,
+            cacheReadPerM: 1
+        }
+    },
+    {
+        match: /^gpt-5\.6-terra/i,
+        inputPerM: 2,
+        outputPerM: 12,
+        cacheReadPerM: 0.2,
+        abovePromptTokens: {
+            threshold: 272_000,
+            inputPerM: 4,
+            outputPerM: 18,
+            cacheReadPerM: 0.4
+        }
+    },
+    {
+        match: /^gpt-5\.6-luna/i,
+        inputPerM: 0.2,
+        outputPerM: 1.2,
+        cacheReadPerM: 0.02,
+        abovePromptTokens: {
+            threshold: 272_000,
+            inputPerM: 0.4,
+            outputPerM: 1.8,
+            cacheReadPerM: 0.04
+        }
+    },
     { match: /^gpt-5\.5(?:-codex)?/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
     { match: /^gpt-5\.4-mini/i, inputPerM: 0.75, outputPerM: 4.5, cacheReadPerM: 0.075 },
     { match: /^gpt-5\.4-nano/i, inputPerM: 0.2, outputPerM: 1.25, cacheReadPerM: 0.02 },
@@ -38,9 +74,22 @@ const pricingRules = [
     { match: /^o3$/i, inputPerM: 2, outputPerM: 8 },
     { match: /^o4-mini/i, inputPerM: 1.1, outputPerM: 4.4 },
     // Google (Gemini API list prices)
-    { match: /^gemini-2\.5-pro/i, inputPerM: 1.25, outputPerM: 10 },
-    { match: /^gemini-2\.5-flash-lite/i, inputPerM: 0.1, outputPerM: 0.4 },
-    { match: /^gemini-2\.5-flash/i, inputPerM: 0.3, outputPerM: 2.5 },
+    {
+        match: /^gemini-2\.5-pro$/i,
+        inputPerM: 1.25,
+        outputPerM: 10,
+        cacheReadPerM: 0.125,
+        abovePromptTokens: {
+            threshold: 200_000,
+            inputPerM: 2.5,
+            outputPerM: 15,
+            cacheReadPerM: 0.25
+        }
+    },
+    // Gemini CLI's persisted Flash/Flash-Lite summary does not retain token
+    // modality, while published audio and non-audio input/cache rates differ.
+    // Until modality is explicit, returning undefined is safer than silently
+    // applying the text/image/video rate to a potentially multimodal request.
     // DeepSeek (official API list prices)
     { match: /^deepseek-chat|^deepseek-v3/i, inputPerM: 0.27, outputPerM: 1.1 },
     { match: /^deepseek-reasoner|^deepseek-r1/i, inputPerM: 0.55, outputPerM: 2.19 },
@@ -61,19 +110,77 @@ export function findPricingRule(model) {
  * published price we recognize.
  */
 export function estimateTokenCostUsd(model, usage) {
+    const usd = rawTokenCostUsd(model, usage);
+    return usd === undefined ? undefined : roundUsd(usd);
+}
+/**
+ * Price request-scoped usage before aggregating it. This is required for
+ * models whose entire request moves to a higher rate above a prompt-size
+ * threshold; pricing a daily token sum would incorrectly treat many small
+ * requests as one large request.
+ */
+export function estimateTokenCostsUsd(model, usages) {
+    let total = 0;
+    for (const usage of usages) {
+        const usd = rawTokenCostUsd(model, usage);
+        if (usd === undefined)
+            return undefined;
+        total += usd;
+    }
+    return roundUsd(total);
+}
+/** Whether this model's rate selection depends on each request's prompt size. */
+export function usesPromptTieredPricing(model) {
+    return promptTierThreshold(model) !== undefined;
+}
+/** Prompt-size threshold for tiered request pricing, when one is published. */
+export function promptTierThreshold(model) {
+    return findPricingRule(model)?.abovePromptTokens?.threshold;
+}
+/**
+ * Tiered prices are selected per request, never from a multi-request sum.
+ * An aggregate is still unambiguous when its entire non-negative prompt-side
+ * total is at or below the threshold; then no constituent request can have
+ * crossed it. Larger aggregates fail closed until request-level evidence is
+ * available.
+ */
+export function canPriceTokenUsageAtScope(model, usage, scope) {
+    const threshold = promptTierThreshold(model);
+    if (threshold === undefined || scope === "request")
+        return true;
+    return effectivePromptTokens(usage) <= threshold;
+}
+function rawTokenCostUsd(model, usage) {
     const rule = findPricingRule(model);
     if (!rule) {
         return undefined;
     }
-    const cacheRead = rule.cacheReadPerM ?? rule.inputPerM * 0.1;
-    const write5m = rule.cacheWrite5mPerM ?? rule.inputPerM * 1.25;
-    const write1h = rule.cacheWrite1hPerM ?? rule.inputPerM * 2;
-    const usd = (usage.inputTokens * rule.inputPerM +
-        usage.outputTokens * rule.outputPerM +
+    const promptTokens = effectivePromptTokens(usage);
+    const rates = rule.abovePromptTokens &&
+        promptTokens > rule.abovePromptTokens.threshold
+        ? rule.abovePromptTokens
+        : rule;
+    const cacheRead = rates.cacheReadPerM ?? rates.inputPerM * 0.1;
+    const write5m = rates.cacheWrite5mPerM ?? rates.inputPerM * 1.25;
+    const write1h = rates.cacheWrite1hPerM ?? rates.inputPerM * 2;
+    const usd = (usage.inputTokens * rates.inputPerM +
+        usage.outputTokens * rates.outputPerM +
         (usage.cacheReadTokens ?? 0) * cacheRead +
         (usage.cacheWrite5mTokens ?? 0) * write5m +
-        (usage.cacheWrite1hTokens ?? 0) * write1h) /
+        (usage.cacheWrite1hTokens ?? 0) * write1h +
+        (usage.thoughtTokens ?? 0) * rates.outputPerM +
+        (usage.toolTokens ?? 0) * rates.inputPerM) /
         1_000_000;
+    return usd;
+}
+function effectivePromptTokens(usage) {
+    return usage.inputTokens +
+        (usage.cacheReadTokens ?? 0) +
+        (usage.cacheWrite5mTokens ?? 0) +
+        (usage.cacheWrite1hTokens ?? 0) +
+        (usage.toolTokens ?? 0);
+}
+function roundUsd(usd) {
     return Math.round(usd * 10_000) / 10_000;
 }
 //# sourceMappingURL=modelPricing.js.map

package/dist/planMath.js

@@ -54,9 +54,9 @@ export function computePlanChecks(records, detectedPlans = []) {
             const savingsVsApi = roundMoney(monthly - detectedKnown.monthlyUsd);
             effectiveSavings = savingsVsApi > 0 ? savingsVsApi : undefined;
             headline =
-                `${agent}: ~$${monthly.toFixed(2)}/mo at API rates (${basis}) — compared with ${detectedKnown.name} ` +
+                `${agent}: ~${formatUsd(monthly)}/mo at API rates (${basis}) — compared with ${detectedKnown.name} ` +
                     `($${detectedKnown.monthlyUsd}/mo; label detected locally): ~${valueMultiple}× the plan price in API-equivalent usage` +
-                    (effectiveSavings ? `, a ~$${effectiveSavings.toFixed(2)}/mo value difference to investigate.` : `.`);
+                    (effectiveSavings ? `, a ~${formatUsd(effectiveSavings)}/mo value difference to investigate.` : `.`);
             if (monthly > detectedKnown.coversUpToUsd) {
                 const nextTier = subscriptionPlans.find((plan) => plan.agent === agent && plan.coversUpToUsd > detectedKnown.coversUpToUsd);
                 // A local limit signal upgrades "might hit limits" to hard evidence.
@@ -75,7 +75,7 @@ export function computePlanChecks(records, detectedPlans = []) {
             // Detected a plan we can't price (e.g. an unrecognized tier): state the
             // fact, then fall back to suggestion math without pretending certainty.
             headline =
-                `${agent}: ~$${monthly.toFixed(2)}/mo at API rates (${basis}) — compared with ${detected.planLabel} ` +
+                `${agent}: ~${formatUsd(monthly)}/mo at API rates (${basis}) — compared with ${detected.planLabel} ` +
                     `(label detected locally; price not in our table)` +
                     (suggested ? `; reference listed plan: ${suggested.name} ($${suggested.monthlyUsd}/mo).` : `.`);
         }
@@ -84,13 +84,13 @@ export function computePlanChecks(records, detectedPlans = []) {
             valueMultiple = covered ? Math.round((monthly / suggested.monthlyUsd) * 10) / 10 : undefined;
             effectiveSavings = covered ? savings : undefined;
             if (!suggested) {
-                headline = `${agent}: ~$${monthly.toFixed(2)}/mo at API rates (${basis}).`;
+                headline = `${agent}: ~${formatUsd(monthly)}/mo at API rates (${basis}).`;
             }
             else if (covered) {
-                headline = `${agent}: ~$${monthly.toFixed(2)}/mo at API rates (${basis}) — ${suggested.name} is a $${suggested.monthlyUsd}/mo reference point. That is ~${valueMultiple}× the plan price in API-equivalent usage, a ~$${savings.toFixed(2)}/mo value difference to investigate; it does not prove plan coverage.`;
+                headline = `${agent}: ~${formatUsd(monthly)}/mo at API rates (${basis}) — ${suggested.name} is a $${suggested.monthlyUsd}/mo reference point. That is ~${valueMultiple}× the plan price in API-equivalent usage, a ~${formatUsd(savings)}/mo value difference to investigate; it does not prove plan coverage.`;
             }
             else {
-                headline = `${agent}: ~$${monthly.toFixed(2)}/mo at API rates (${basis}) — below the $${suggested.monthlyUsd}/mo price of ${suggested.name}; compare account benefits and provider-reported charges before changing plans.`;
+                headline = `${agent}: ~${formatUsd(monthly)}/mo at API rates (${basis}) — below the $${suggested.monthlyUsd}/mo price of ${suggested.name}; compare account benefits and provider-reported charges before changing plans.`;
             }
         }
         checks.push({
@@ -108,6 +108,11 @@ export function computePlanChecks(records, detectedPlans = []) {
     return checks.sort((left, right) => right.apiEquivalentMonthlyUsd - left.apiEquivalentMonthlyUsd);
 }
 function roundMoney(value) {
-    return Math.round(value * 100) / 100;
+    return Math.round(value * 10_000) / 10_000;
+}
+function formatUsd(value) {
+    if (value > 0 && value < 0.01)
+        return "<$0.01";
+    return `$${value.toFixed(2)}`;
 }
 //# sourceMappingURL=planMath.js.map

package/dist/providerConnectors.d.ts

@@ -56,6 +56,21 @@ export type ProviderQaSummary = {
     instructions: string[];
 };
 export type ProviderId = "openai" | "anthropic" | "github-copilot" | "cursor" | string;
+export type ProviderConnectorErrorCode = "authentication_error" | "provider_request_error";
+/**
+ * Trusted connector failure metadata. Provider prose remains untrusted and is
+ * used only as a sanitized human-readable message; callers classify failures
+ * from this product-authored code and the observed HTTP status instead.
+ */
+export declare class ProviderConnectorError extends Error {
+    readonly code: ProviderConnectorErrorCode;
+    readonly status?: number;
+    constructor(message: string, options: {
+        code: ProviderConnectorErrorCode;
+        status?: number;
+    });
+}
+export declare function isProviderAuthenticationError(error: unknown): boolean;
 export type ProviderConnectorInput = {
     provider: ProviderId;
     sourceId?: string;
@@ -109,6 +124,7 @@ export declare function normalizeGitHubCopilotMetricsResponse(response: unknown,
 export declare function normalizeCursorSpendResponse(response: unknown, options: NormalizerOptions): UsageRecord[];
 export declare function fetchProviderUsageRecords(input: ProviderConnectorInput): Promise<ProviderConnectorResult>;
 export declare function summarizeProviderFinancials(records: UsageRecord[]): ProviderFinancialSummary;
+export declare function providerFinancialCompleteness(records: UsageRecord[], coverage: ProviderCoverageStatus): ProviderConnectorResult["completeness"];
 /**
  * Keep evidence records available to callers, but never add estimates to a
  * provider's official billed total. This selection is intended for aggregate