@kunal_dutt/token-lens 0.0.0-stage → 0.2.17

package/types/src/core/tasks.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Work out what the user is doing from the prompt itself, so optimization can
+ * adapt to the task: debugging wants its logs trimmed, editing must leave the
+ * pasted text alone, a quick question benefits from a length cap, and so on.
+ */
+export type Task = "coding" | "debugging" | "writing" | "editing" | "summarizing" | "translation" | "research" | "analysis" | "brainstorming" | "chat";
+export declare const TASK_LABELS: Record<Task, string>;
+export interface TaskSignals {
+    /** Contains fenced code or lines that look like source code. */
+    hasCode: boolean;
+    /** Contains log lines or a stack trace. */
+    hasLogs: boolean;
+    /** Contains tabular / JSON data. */
+    hasData: boolean;
+    /** Estimated tokens of material pasted below the instruction. */
+    pastedTokens: number;
+    /** The prompt already says how long or in what shape the answer should be. */
+    hasLengthLimit: boolean;
+    /** The prompt asks for a whole file / full rewrite back. */
+    asksForFullOutput: boolean;
+}
+export interface TaskInfo {
+    task: Task;
+    /** 0..1, how sure the classifier is. */
+    confidence: number;
+    signals: TaskSignals;
+}
+export declare const CODE_LINE_RE: RegExp;
+export declare const LOG_LINE_RE: RegExp;
+/**
+ * Split a prompt into the instruction (first paragraph) and pasted material
+ * (the rest). Prompts usually lead with the ask and paste below it.
+ */
+export declare function splitInstruction(text: string): {
+    instruction: string;
+    material: string;
+};
+export declare function detectTask(text: string): TaskInfo;
+/**
+ * Tasks where text pasted below the instruction is the user's own notes and
+ * can be tightened. For every other task it is source material (the text to
+ * edit, summarize or translate, code, logs, data) and is left as written.
+ */
+export declare const COMPRESSIBLE_MATERIAL: ReadonlySet<Task>;

package/types/src/core/tokens.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Token counting, adapted to the model's tokenizer.
+ *
+ * OpenAI models get an exact count from the o200k tokenizer (bundled, works
+ * offline). Families without a public offline tokenizer get an estimate from
+ * characters and word pieces, tuned per family, and are marked `exact: false`.
+ */
+import type { ModelProfile } from "./models";
+export interface TokenCount {
+    tokens: number;
+    exact: boolean;
+}
+/**
+ * BPE tokenizers average ~4 characters per token on English prose but split
+ * punctuation, digits and rare words more aggressively, so take the larger of
+ * a character-based estimate and a count of word pieces.
+ */
+export declare function estimateTokens(text: string, charsPerToken?: number): number;
+export declare function countTokens(text: string, profile: ModelProfile): TokenCount;

package/types/src/core/verify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Evidence that an optimized agent behaves the same: every check compares the
+ * original and optimized spec and says what was compared. The success
+ * criterion is fewer tokens with the agent's work unchanged, so a change that
+ * fails any check is not applied.
+ */
+import type { AgentSpec } from "./hotspots";
+export interface Check {
+    name: string;
+    passed: boolean;
+    detail: string;
+}
+export interface Verification {
+    passed: boolean;
+    checks: Check[];
+}
+/** Is this rewrite of one text safe? Facts/constraints kept and no instruction words lost. */
+export declare function textEquivalent(original: string, rewritten: string): boolean;
+export declare function verifyEquivalent(before: AgentSpec, after: AgentSpec): Verification;

package/types/src/gateway/config.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Gateway configuration: a JSON file (TOKEN_LENS_CONFIG) plus environment
+ * shortcuts, so the simplest deployment needs only an API key.
+ *
+ * Secrets are never written in the file itself: any string value of the form
+ * "env:NAME" is read from the environment variable NAME.
+ */
+import type { CustomModel, Level } from "../core";
+import type { StorageConfig } from "./shared";
+export type UpstreamType = "openai" | "anthropic";
+export interface UpstreamConfig {
+    /**
+     * "openai": any OpenAI-compatible API (OpenAI, Azure OpenAI v1, vLLM, TGI,
+     * Ollama, LiteLLM, Together, Groq, an in-house model server…).
+     * "anthropic": the Anthropic Messages API (or a compatible endpoint).
+     */
+    type: UpstreamType;
+    /** As in the official SDKs: "https://api.openai.com/v1", "https://api.anthropic.com". */
+    baseUrl: string;
+    /** Upstream key. When unset, the caller's own key is passed through. */
+    apiKey?: string;
+    /** How the key is sent: Bearer token (OpenAI), x-api-key (Anthropic) or api-key (Azure). */
+    authHeader?: "authorization" | "x-api-key" | "api-key";
+    /** Extra headers sent upstream on every request. */
+    headers?: Record<string, string>;
+    /** Offers OpenAI's Batch API (/files + /batches). Default: on for api.openai.com and Anthropic. */
+    batch?: boolean;
+    /** Offers OpenAI's flex service tier. Default: on for api.openai.com only. */
+    flex?: boolean;
+    /** Send OpenAI's prompt_cache_key so calls in one run share a cache. Default: on for api.openai.com only. */
+    promptCacheKey?: boolean;
+}
+export interface Route {
+    /** Model id glob, e.g. "acme-*" or "gpt-4o*". */
+    model: string;
+    upstream: string;
+}
+export interface ClientKey {
+    name: string;
+    key: string;
+}
+export type Mode = "optimize" | "observe" | "off";
+/** Optimizations that never change what the request means. On by default. */
+export interface SafeOptimizations {
+    /** Rewrite the newest user message with the core optimizer (code, quotes and pasted material stay verbatim). */
+    prompt: boolean;
+    /** Re-serialize pretty-printed JSON in tool outputs without whitespace. */
+    minifyJson: boolean;
+    /** Collapse runs of identical lines in tool outputs ("[previous line repeated 40 more times]"). */
+    collapseRepeats: boolean;
+    /** A tool output identical to an earlier one in the same conversation is sent once; later copies point back to it. */
+    dedupeToolOutputs: boolean;
+    /** Send a passage repeated within a request (retrieved chunks, quoted documents) once. */
+    dedupePassages: boolean;
+    /** Send an image repeated later in the conversation once. */
+    dedupeImages: boolean;
+    /** Add prompt-caching breakpoints / cache keys once a run repeats a large prefix. */
+    promptCaching: boolean;
+    /** Replay the response to an identical temperature-0, non-streamed request seen in the last `retryWindowSeconds`. */
+    dedupeRetries: boolean;
+    /**
+     * Embeddings (/v1/embeddings): a text this team already embedded with the same
+     * model and settings is answered from memory; only new texts go upstream.
+     * Texts aren't stored, only a hash of each and its vector.
+     */
+    cacheEmbeddings: boolean;
+}
+/** Optimizations that can change the answer. Off unless enabled here or per request. */
+export interface OptInOptimizations {
+    /** Replace tool outputs older than the newest `keepLast` with a short stub. */
+    elideOldToolOutputs: false | {
+        keepLast: number;
+        minTokens: number;
+    };
+    /**
+     * Send tools the run hasn't used yet as a name and one-line summary, and load
+     * a tool's full definition only when the model asks for it. Applies to
+     * non-streamed requests with at least `minTools` function tools.
+     */
+    lazyTools: false | {
+        minTools: number;
+    };
+    /**
+     * In older tool outputs (JSON), leave out fields the agent never referred to
+     * later in the conversation. Keeps the newest `keepLast` outputs whole.
+     */
+    trimToolFields: false | {
+        keepLast: number;
+    };
+    /** Write lists of records in JSON tool outputs as column names plus rows. */
+    compactJson: boolean;
+    /**
+     * Keep older tool outputs over `minTokens` outside the conversation (their first
+     * lines and an id stay), with a reader tool the model calls to search or slice
+     * them. Non-streamed OpenAI Chat and Anthropic requests.
+     */
+    parkToolOutputs: false | {
+        minTokens: number;
+        keepLast: number;
+    };
+    /**
+     * The provider's cheaper, slower processing on the same model (OpenAI's
+     * service_tier "flex"). Falls back to the normal tier when flex is unavailable.
+     */
+    flex: boolean;
+    /**
+     * When several calls with the same large prefix arrive at once, send the first
+     * alone and hold the rest (up to `maxWaitMs`) so they read its cache.
+     */
+    warmCache: false | {
+        maxWaitMs: number;
+    };
+}
+/**
+ * Output checks: for a sample of optimized calls, also send the original
+ * request and compare the answers, as evidence the work is unchanged.
+ */
+export interface VerifyConfig {
+    /** Share of optimized calls to check, 0..1; 0 turns checks off. Calls using an opt-in fix are checked at least 25% of the time. */
+    sampleRate: number;
+    /** Text similarity (0..1) at or above which two answers count as the same; tool calls must match exactly. */
+    minSimilarity: number;
+    /**
+     * Checks cost tokens too: after the first `freeChecks` per team and agent, a call
+     * is only checked while check tokens stay under this share of tokens saved.
+     */
+    maxShareOfSavings: number;
+    freeChecks: number;
+    /**
+     * Opt-in fixes are on probation for each team and agent until this many answers
+     * in a row matched the original's: until then the original is sent alongside
+     * and the app gets the optimized answer only when it matches.
+     */
+    probation: number;
+}
+/**
+ * A spending limit per run, off by default. Once a run reaches it, further calls
+ * get an error instead of being sent, which stops a looping agent from running
+ * up cost. Can also be set per request with x-token-lens-max-calls and
+ * x-token-lens-max-cost-usd.
+ */
+export interface RunBudget {
+    maxCalls?: number;
+    maxCostUsd?: number;
+}
+export interface GatewayConfig {
+    port: number;
+    host: string;
+    mode: Mode;
+    level: Level | "auto";
+    safe: SafeOptimizations;
+    optIn: OptInOptimizations;
+    verify: VerifyConfig;
+    runBudget: RunBudget;
+    /** Work that can wait (x-token-lens-batch): how often queued calls go out and results are checked, and the price factor. */
+    batch: {
+        flushSeconds: number;
+        pollSeconds: number;
+        maxRequests: number;
+        discount: number;
+    };
+    /** Price factor of the flex tier against the normal one. */
+    flexDiscount: number;
+    /** Memory for cached embeddings, per gateway. */
+    embeddingsCacheMB: number;
+    /**
+     * Models that charge a higher rate once a request passes a size (for some
+     * models, every token of a request above about 200K input tokens). Matched by
+     * model id glob. Built-in models already carry their list price for this
+     * (Gemini Pro above 200K input tokens); add or override models here.
+     */
+    priceTiers: PriceTier[];
+    /** Shared report storage (Redis, or a file); off by default, everything stays in memory. */
+    storage: StorageConfig;
+    retryWindowSeconds: number;
+    /** Reject requests that cannot fit the model's context window before paying for them. */
+    blockOverContext: boolean;
+    upstreams: Record<string, UpstreamConfig>;
+    routes: Route[];
+    /** Upstream for OpenAI-style requests no route matches. */
+    defaultUpstream?: string;
+    /** Custom models: a company's own LLM, or exact numbers for a built-in one. */
+    models: CustomModel[];
+    /** Keys callers must present. Empty: no gateway auth (only for private networks). */
+    clientKeys: ClientKey[];
+    /** Key for the admin endpoints (registering models at runtime). */
+    adminKey?: string;
+    maxBodyBytes: number;
+    /** Runs kept in memory for /token-lens/runs. */
+    maxRuns: number;
+    logRequests: boolean;
+    /**
+     * Show tool-call inputs (which may hold customer data) in run reports. Off by
+     * default: repeats are still detected, and reports name the input by a short hash.
+     */
+    reportToolArgs: boolean;
+}
+export interface PriceTier {
+    model: string;
+    aboveInputTokens: number;
+    /** Rates for the whole request once it is above the limit, USD per million tokens. */
+    inputPerMTok: number;
+    outputPerMTok: number;
+}
+export declare const DEFAULTS: GatewayConfig;
+type Env = Record<string, string | undefined>;
+/** The config file: every field optional, nested sections merged with the defaults. */
+export type ConfigFile = Partial<Omit<GatewayConfig, "safe" | "optIn" | "verify" | "batch" | "storage">> & {
+    safe?: Partial<SafeOptimizations>;
+    optIn?: Partial<OptInOptimizations>;
+    verify?: Partial<VerifyConfig>;
+    batch?: Partial<GatewayConfig["batch"]>;
+    storage?: Partial<StorageConfig>;
+};
+export declare function buildConfig(partial?: ConfigFile, env?: Env): GatewayConfig;
+export declare function loadConfig(env?: Env): GatewayConfig;
+export {};

package/types/src/gateway/guard.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Keeps answers unchanged: the rule every gateway fix follows.
+ *
+ * - A fix that was in play when an output check found a different answer is
+ *   switched off for that team and agent, unless the model's own answers to the
+ *   original request differ just as much (then the fix isn't the cause). It
+ *   stays off until an admin turns it back on (POST /token-lens/guard/reset).
+ * - Fixes that can change an answer by design (opt-in: elide-tool-outputs,
+ *   lazy-tools, trim-tool-fields) start on probation: the gateway sends the original request
+ *   alongside and answers with the optimized result only when the two match;
+ *   otherwise the app gets the original's answer. After `probation` matches in a
+ *   row the fix runs on its own, with output checks sampled as usual.
+ * - While on probation, opt-in fixes are left out of streamed and batched calls,
+ *   whose answer can't be compared before the app gets it.
+ */
+import type { GatewayConfig } from "./config";
+import type { Check } from "./verify";
+export declare const OPT_IN_FIXES: Set<string>;
+export declare const guardable: (id: string) => boolean;
+export declare class OutputGuard {
+    private probation;
+    private states;
+    constructor(probation: number);
+    private state;
+    /** The settings for one request: switched-off fixes removed, and opt-in fixes on probation removed where the answer can't be compared first. */
+    configFor(cfg: GatewayConfig, app: string, agent: string, allow: Set<string>, uncheckable: boolean): {
+        cfg: GatewayConfig;
+        allow: Set<string>;
+    };
+    /** The opt-in fixes among `ids` that still need their answer compared before it is sent. */
+    onProbation(app: string, agent: string, ids: string[]): string[];
+    confirm(app: string, agent: string, ids: string[]): void;
+    /** Switches off every fix that was in play when an answer changed. */
+    suspend(app: string, agent: string, ids: string[], check: Pick<Check, "at" | "similarity" | "sameToolCalls">): string[];
+    isSuspended(app: string, agent: string, id: string): boolean;
+    /** Turns fixes back on (all, one app, or one app and agent). Opt-in fixes start a new probation. */
+    reset(app?: string, agent?: string): number;
+    /** Makes the switched-off fixes exactly `list` (from shared storage, so every gateway copy agrees). */
+    replaceSuspended(list: Array<{
+        app: string;
+        agent: string;
+        fix: string;
+        since: string;
+        similarity: number;
+        sameToolCalls: boolean;
+    }>): void;
+    /** Switched-off fixes, for stats and the report. */
+    list(): Array<{
+        app: string;
+        agent: string;
+        fix: string;
+        since: string;
+        similarity: number;
+        sameToolCalls: boolean;
+    }>;
+}

package/types/src/gateway/images.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Images in requests: what they cost, and sending a repeated image once.
+ *
+ * Image tokens are estimated from each image's size with the provider's own
+ * published rules. Hosted providers shrink large images before counting them,
+ * so sending an image smaller than their limit saves upload time but not
+ * tokens. The token savings come from not re-sending the same image, cropping,
+ * or a lower detail setting where it is enough (which can change answers).
+ */
+import type { Protocol } from "./protocol";
+export interface ImageRef {
+    /** Position of the message in the conversation. */
+    turn: number;
+    /** Same key, same image (hash of the data or the URL). */
+    key: string;
+    width?: number;
+    height?: number;
+    detail?: string;
+    /** Replaces the image with a text note. */
+    replace(text: string): void;
+}
+/** Width and height from the first bytes of a PNG, JPEG, GIF or WebP file. */
+export declare function imageSize(buf: Buffer): {
+    width: number;
+    height: number;
+} | undefined;
+/** Every image in the request, in order, with a way to replace it by text. */
+export declare function findImages(protocol: Protocol, body: any): ImageRef[];
+/**
+ * Estimated input tokens for one image, after the provider's own resizing.
+ * Anthropic: about width × height / 750 once the long edge fits 1,568 px (at most
+ * about 1,600 tokens). OpenAI tile models: 85 + 170 per 512 px tile after fitting
+ * 2,048 px and a 768 px short side; "low" detail is 85. Unknown size: undefined.
+ */
+export declare function imageTokens(provider: "openai" | "anthropic", img: Pick<ImageRef, "width" | "height" | "detail">): number | undefined;
+/** Replaces later copies of an image with a note pointing to the first. Returns the tokens saved and how many. */
+export declare function dedupeImages(images: ImageRef[], provider: "openai" | "anthropic"): {
+    saved: number;
+    count: number;
+};

package/types/src/gateway/metrics.d.ts

@@ -0,0 +1,287 @@
+/**
+ * Savings accounting: tokens and money before and after Token Lens, per team
+ * (client key), agent, model and run, next to the output checks that show the
+ * work was unchanged.
+ *
+ * "Before" is what the same calls would have cost without the gateway: the
+ * tokens it removed added back, cached input priced as normal input, replayed
+ * retries paid in full. "After" is what was actually billed. The output checks'
+ * own extra calls are reported separately, so the net saving is honest.
+ */
+import type { ModelProfile } from "../core";
+import type { Usage } from "./protocol";
+export interface Totals {
+    requests: number;
+    errors: number;
+    replayed: number;
+    /** Input tokens actually sent (including cached). */
+    inputTokens: number;
+    /** Input tokens the same calls would have sent without Token Lens. */
+    inputTokensBefore: number;
+    outputTokens: number;
+    /** Output tokens not generated because a retry was replayed. */
+    outputTokensAvoided: number;
+    cachedInputTokens: number;
+    reasoningTokens: number;
+    savedInputTokens: number;
+    costUsd: number;
+    costBeforeUsd: number;
+    /** Calls that have a price (a model without pricing counts tokens only). */
+    pricedRequests: number;
+    checks: number;
+    checksMatched: number;
+    checkCostUsd: number;
+}
+export declare const emptyTotals: () => Totals;
+/** A model's higher rate for the whole request once its input passes a size. */
+export interface PriceTierRates {
+    aboveInputTokens: number;
+    inputPerMTok: number;
+    outputPerMTok: number;
+}
+/** A profile, with the higher-price tier of the model actually called when it has one. */
+export type Priced = ModelProfile & {
+    priceTier?: PriceTierRates;
+};
+/** Billed cost of a call's usage: cached reads and cache writes at their own rates when known. */
+export declare function cost(profile: Priced, usage: Usage): number;
+/** What a call would have cost without Token Lens: removed tokens back, no cache discount. */
+export declare function costBefore(profile: Priced, usage: Usage, savedInput: number): number;
+export interface CallMetrics {
+    app: string;
+    agent: string;
+    run: string;
+    profile: Priced;
+    status: number;
+    usage: Usage;
+    /** Price multiplier the provider applied (0.5 for its batch option). */
+    priceFactor?: number;
+    /** Gateway's own input count, used when the upstream doesn't report usage. */
+    estimatedInput: number;
+    savedInput: number;
+    replayed: boolean;
+}
+/** Add one call to a totals row. */
+export declare function addCall(t: Totals, m: Omit<CallMetrics, "app" | "agent" | "run">): void;
+export declare class Metrics {
+    /** Keyed by app, agent and model. */
+    private rows;
+    readonly started: string;
+    private row;
+    record(m: CallMetrics): void;
+    /** One output check; `counted` false records only the cost of an extra call made for a check. */
+    recordCheck(app: string, agent: string, profile: ModelProfile, matched: boolean, checkCost: number, counted?: boolean): void;
+    /** The raw rows (key: team, agent and model), for shared storage. */
+    snapshot(): Map<string, Totals>;
+    private grouped;
+    /** One row per team, agent and model, for exports. */
+    detail(rows?: Map<string, Totals>): {
+        costUsd: number;
+        costBeforeUsd: number;
+        checkCostUsd: number;
+        savedTokens: number;
+        savedTokensPct: number;
+        savedUsd: number;
+        savedUsdPct: number;
+        netSavedUsd: number;
+        outputUnchangedPct: number;
+        unpricedRequests: number;
+        requests: number;
+        errors: number;
+        replayed: number;
+        /** Input tokens actually sent (including cached). */
+        inputTokens: number;
+        /** Input tokens the same calls would have sent without Token Lens. */
+        inputTokensBefore: number;
+        outputTokens: number;
+        /** Output tokens not generated because a retry was replayed. */
+        outputTokensAvoided: number;
+        cachedInputTokens: number;
+        reasoningTokens: number;
+        savedInputTokens: number;
+        /** Calls that have a price (a model without pricing counts tokens only). */
+        pricedRequests: number;
+        checks: number;
+        checksMatched: number;
+    }[];
+    /** Totals by team, agent and model; `rows` from shared storage when given, else this gateway's own. */
+    json(rows?: Map<string, Totals>, since?: string): {
+        since: string;
+        total: {
+            costUsd: number;
+            costBeforeUsd: number;
+            checkCostUsd: number;
+            savedTokens: number;
+            savedTokensPct: number;
+            savedUsd: number;
+            savedUsdPct: number;
+            netSavedUsd: number;
+            outputUnchangedPct: number;
+            unpricedRequests: number;
+            requests: number;
+            errors: number;
+            replayed: number;
+            /** Input tokens actually sent (including cached). */
+            inputTokens: number;
+            /** Input tokens the same calls would have sent without Token Lens. */
+            inputTokensBefore: number;
+            outputTokens: number;
+            /** Output tokens not generated because a retry was replayed. */
+            outputTokensAvoided: number;
+            cachedInputTokens: number;
+            reasoningTokens: number;
+            savedInputTokens: number;
+            /** Calls that have a price (a model without pricing counts tokens only). */
+            pricedRequests: number;
+            checks: number;
+            checksMatched: number;
+        };
+        byTeam: {
+            costUsd: number;
+            costBeforeUsd: number;
+            checkCostUsd: number;
+            savedTokens: number;
+            savedTokensPct: number;
+            savedUsd: number;
+            savedUsdPct: number;
+            netSavedUsd: number;
+            outputUnchangedPct: number;
+            unpricedRequests: number;
+            requests: number;
+            errors: number;
+            replayed: number;
+            /** Input tokens actually sent (including cached). */
+            inputTokens: number;
+            /** Input tokens the same calls would have sent without Token Lens. */
+            inputTokensBefore: number;
+            outputTokens: number;
+            /** Output tokens not generated because a retry was replayed. */
+            outputTokensAvoided: number;
+            cachedInputTokens: number;
+            reasoningTokens: number;
+            savedInputTokens: number;
+            /** Calls that have a price (a model without pricing counts tokens only). */
+            pricedRequests: number;
+            checks: number;
+            checksMatched: number;
+        }[];
+        byAgent: {
+            costUsd: number;
+            costBeforeUsd: number;
+            checkCostUsd: number;
+            savedTokens: number;
+            savedTokensPct: number;
+            savedUsd: number;
+            savedUsdPct: number;
+            netSavedUsd: number;
+            outputUnchangedPct: number;
+            unpricedRequests: number;
+            requests: number;
+            errors: number;
+            replayed: number;
+            /** Input tokens actually sent (including cached). */
+            inputTokens: number;
+            /** Input tokens the same calls would have sent without Token Lens. */
+            inputTokensBefore: number;
+            outputTokens: number;
+            /** Output tokens not generated because a retry was replayed. */
+            outputTokensAvoided: number;
+            cachedInputTokens: number;
+            reasoningTokens: number;
+            savedInputTokens: number;
+            /** Calls that have a price (a model without pricing counts tokens only). */
+            pricedRequests: number;
+            checks: number;
+            checksMatched: number;
+        }[];
+        byModel: {
+            costUsd: number;
+            costBeforeUsd: number;
+            checkCostUsd: number;
+            savedTokens: number;
+            savedTokensPct: number;
+            savedUsd: number;
+            savedUsdPct: number;
+            netSavedUsd: number;
+            outputUnchangedPct: number;
+            unpricedRequests: number;
+            requests: number;
+            errors: number;
+            replayed: number;
+            /** Input tokens actually sent (including cached). */
+            inputTokens: number;
+            /** Input tokens the same calls would have sent without Token Lens. */
+            inputTokensBefore: number;
+            outputTokens: number;
+            /** Output tokens not generated because a retry was replayed. */
+            outputTokensAvoided: number;
+            cachedInputTokens: number;
+            reasoningTokens: number;
+            savedInputTokens: number;
+            /** Calls that have a price (a model without pricing counts tokens only). */
+            pricedRequests: number;
+            checks: number;
+            checksMatched: number;
+        }[];
+        byAppAndModel: {
+            costUsd: number;
+            costBeforeUsd: number;
+            checkCostUsd: number;
+            savedTokens: number;
+            savedTokensPct: number;
+            savedUsd: number;
+            savedUsdPct: number;
+            netSavedUsd: number;
+            outputUnchangedPct: number;
+            unpricedRequests: number;
+            requests: number;
+            errors: number;
+            replayed: number;
+            /** Input tokens actually sent (including cached). */
+            inputTokens: number;
+            /** Input tokens the same calls would have sent without Token Lens. */
+            inputTokensBefore: number;
+            outputTokens: number;
+            /** Output tokens not generated because a retry was replayed. */
+            outputTokensAvoided: number;
+            cachedInputTokens: number;
+            reasoningTokens: number;
+            savedInputTokens: number;
+            /** Calls that have a price (a model without pricing counts tokens only). */
+            pricedRequests: number;
+            checks: number;
+            checksMatched: number;
+        }[];
+    };
+    prometheus(): string;
+}
+/** A totals row with the derived savings figures. */
+export declare function view(t: Totals): {
+    costUsd: number;
+    costBeforeUsd: number;
+    checkCostUsd: number;
+    savedTokens: number;
+    savedTokensPct: number;
+    savedUsd: number;
+    savedUsdPct: number;
+    netSavedUsd: number;
+    outputUnchangedPct: number;
+    unpricedRequests: number;
+    requests: number;
+    errors: number;
+    replayed: number;
+    /** Input tokens actually sent (including cached). */
+    inputTokens: number;
+    /** Input tokens the same calls would have sent without Token Lens. */
+    inputTokensBefore: number;
+    outputTokens: number;
+    /** Output tokens not generated because a retry was replayed. */
+    outputTokensAvoided: number;
+    cachedInputTokens: number;
+    reasoningTokens: number;
+    savedInputTokens: number;
+    /** Calls that have a price (a model without pricing counts tokens only). */
+    pricedRequests: number;
+    checks: number;
+    checksMatched: number;
+};