@agent-finops/core 0.7.3 → 0.8.0

package/dist/modelPricing.js

@@ -7,7 +7,7 @@
  * 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-13";
 const pricingRules = [
     // Anthropic
     { match: /^claude-fable-5/i, inputPerM: 10, outputPerM: 50 },
@@ -18,9 +18,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 +71,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 +107,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/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