captchakraken 2.8.0 → 3.0.0

package/dist/timing.d.ts

@@ -1,48 +1,15 @@
-/**
- * Where one solve's wall-clock went, by phase.
- *
- * The TypeScript half of `python/src/captchakraken/timing.py`; the two are one
- * implementation in two languages and `test_timing_parity.py` pins that they
- * name the same phases. That parity is the point: without it the ports can only
- * be compared on their totals, and "the JS port is four seconds slower" is not
- * a bug report — "the JS port spends four seconds starting a Python
- * interpreter it did not need to start" is.
- *
- * Always on. It is a few map updates per phase against multi-second waits, and
- * a budget you have to opt into is one nobody has when the slow solve happens.
- * Only PRINTED under `CAPTCHA_TIMINGS=1`; always RETURNED on `SolveResult`.
- */
-/**
- * What a phase's time COUNTS AS, when asking how much of a solve was useful.
- *
- * Only two kinds of second are worth spending: one the model is thinking in,
- * and one the pointer is travelling in (which has to look human, so it cannot
- * be rushed). Everything else is the driver waiting on a clock, and every such
- * wait is a candidate for deletion or for overlapping with something real.
- */
-export declare const PRODUCTIVE: Set<string>;
+import { Phase } from './kinds.js';
+export declare const PRODUCTIVE: ReadonlySet<Phase>;
 export declare function timingsEnabled(): boolean;
+/** Phases attribute, they do not partition: a nested phase counts under both names, and re-entering an open one counts once. */
 export declare class PhaseBudget {
-    readonly totals: Map<string, number>;
-    readonly counts: Map<string, number>;
+    readonly totals: Map<Phase, number>;
+    readonly counts: Map<Phase, number>;
     private readonly open;
     private readonly t0;
-    /**
-     * Attribute `fn`'s wall-clock to `name`.
-     *
-     * Phases may nest (a burst contains its screenshots). Only the OUTERMOST of a
-     * given NAME accumulates, so re-entering one cannot double-count it — but a
-     * phase nested inside a differently-named one counts under both, deliberately:
-     * the cursor drifting over the widget WHILE the model generates is genuinely
-     * both `mouse` and `inference`, and hiding either would misreport what the
-     * solve was doing. The totals are therefore an attribution, not a partition,
-     * and can exceed the elapsed time.
-     */
-    phase<T>(name: string, fn: () => Promise<T>): Promise<T>;
-    /** Record a measured span directly, for blocks that would need re-indenting. */
-    add(name: string, ms: number): void;
+    phase<T>(name: Phase, fn: () => Promise<T>): Promise<T>;
+    add(name: Phase, ms: number): void;
     elapsedMs(): number;
-    /** Plain object for `SolveResult.phases`, with the solve total folded in. */
     toObject(): Record<string, number>;
     report(): string;
 }

package/dist/timing.js

@@ -1,33 +1,14 @@
 "use strict";
-/**
- * Where one solve's wall-clock went, by phase.
- *
- * The TypeScript half of `python/src/captchakraken/timing.py`; the two are one
- * implementation in two languages and `test_timing_parity.py` pins that they
- * name the same phases. That parity is the point: without it the ports can only
- * be compared on their totals, and "the JS port is four seconds slower" is not
- * a bug report — "the JS port spends four seconds starting a Python
- * interpreter it did not need to start" is.
- *
- * Always on. It is a few map updates per phase against multi-second waits, and
- * a budget you have to opt into is one nobody has when the slow solve happens.
- * Only PRINTED under `CAPTCHA_TIMINGS=1`; always RETURNED on `SolveResult`.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PhaseBudget = exports.PRODUCTIVE = void 0;
 exports.timingsEnabled = timingsEnabled;
-/**
- * What a phase's time COUNTS AS, when asking how much of a solve was useful.
- *
- * Only two kinds of second are worth spending: one the model is thinking in,
- * and one the pointer is travelling in (which has to look human, so it cannot
- * be rushed). Everything else is the driver waiting on a clock, and every such
- * wait is a candidate for deletion or for overlapping with something real.
- */
-exports.PRODUCTIVE = new Set(['inference', 'mouse']);
+const kinds_js_1 = require("./kinds.js");
+// Always collected, printed only under CAPTCHA_TIMINGS=1: a budget you have to opt into is one nobody has when the slow solve happens.
+exports.PRODUCTIVE = new Set([kinds_js_1.Phase.INFERENCE, kinds_js_1.Phase.MOUSE]);
 function timingsEnabled() {
     return process.env.CAPTCHA_TIMINGS === '1';
 }
+/** Phases attribute, they do not partition: a nested phase counts under both names, and re-entering an open one counts once. */
 class PhaseBudget {
     constructor() {
         this.totals = new Map();
@@ -35,17 +16,6 @@ class PhaseBudget {
         this.open = [];
         this.t0 = Date.now();
     }
-    /**
-     * Attribute `fn`'s wall-clock to `name`.
-     *
-     * Phases may nest (a burst contains its screenshots). Only the OUTERMOST of a
-     * given NAME accumulates, so re-entering one cannot double-count it — but a
-     * phase nested inside a differently-named one counts under both, deliberately:
-     * the cursor drifting over the widget WHILE the model generates is genuinely
-     * both `mouse` and `inference`, and hiding either would misreport what the
-     * solve was doing. The totals are therefore an attribution, not a partition,
-     * and can exceed the elapsed time.
-     */
     async phase(name, fn) {
         if (this.open.includes(name))
             return fn();
@@ -59,7 +29,6 @@ class PhaseBudget {
             this.add(name, Date.now() - t0);
         }
     }
-    /** Record a measured span directly, for blocks that would need re-indenting. */
     add(name, ms) {
         this.totals.set(name, (this.totals.get(name) ?? 0) + ms);
         this.counts.set(name, (this.counts.get(name) ?? 0) + 1);
@@ -67,7 +36,6 @@ class PhaseBudget {
     elapsedMs() {
         return Date.now() - this.t0;
     }
-    /** Plain object for `SolveResult.phases`, with the solve total folded in. */
     toObject() {
         const out = {};
         for (const [k, v] of this.totals)

package/dist/token-usage.d.ts

@@ -1,11 +1,5 @@
 import { TokenUsage } from './types';
-export interface ModelPricing {
-    inputPricePerM: number;
-    outputPricePerM: number;
-    cachedInputPricePerM: number;
-}
-export declare const PRICING: Record<string, ModelPricing>;
-export declare function estimateCost(usage: TokenUsage): number;
+/** One summed row for a solve. The client has no price list, so `estimatedCost` is always 0. */
 export declare function aggregateTokenUsage(usages: TokenUsage[]): {
     modelName: string;
     inputTokens: number;

package/dist/token-usage.js

@@ -1,102 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PRICING = void 0;
-exports.estimateCost = estimateCost;
 exports.aggregateTokenUsage = aggregateTokenUsage;
-exports.PRICING = {
-    'gemini-3-pro-preview': {
-        inputPricePerM: 2.00,
-        outputPricePerM: 12.00,
-        cachedInputPricePerM: 0.20,
-    },
-    'gemini-3-flash-preview': {
-        inputPricePerM: 0.50,
-        outputPricePerM: 3.00,
-        cachedInputPricePerM: 0.05,
-    },
-    'gemini-2.5-pro': {
-        inputPricePerM: 1.25,
-        outputPricePerM: 10.00,
-        cachedInputPricePerM: 0.125,
-    },
-    'gemini-2.5-flash': {
-        inputPricePerM: 0.30,
-        outputPricePerM: 2.50,
-        cachedInputPricePerM: 0.03,
-    },
-    'gemini-2.5-flash-preview': {
-        inputPricePerM: 0.30,
-        outputPricePerM: 2.50,
-        cachedInputPricePerM: 0.03,
-    },
-    'gemini-2.5-flash-lite': {
-        inputPricePerM: 0.10,
-        outputPricePerM: 0.40,
-        cachedInputPricePerM: 0.01,
-    },
-    'gemini-2.5-flash-lite-preview': {
-        inputPricePerM: 0.10,
-        outputPricePerM: 0.40,
-        cachedInputPricePerM: 0.01,
-    },
-    'gemini-2.0-flash': {
-        inputPricePerM: 0.10,
-        outputPricePerM: 0.40,
-        cachedInputPricePerM: 0.025,
-    },
-    'gemini-2.5-computer-use-preview-10-2025': {
-        inputPricePerM: 1.25,
-        outputPricePerM: 10.00,
-        cachedInputPricePerM: 0.025,
-    }
-};
-// The CaptchaKraken CLI (vLLM/OpenAI shape) emits `prompt_tokens` /
-// `completion_tokens`, while older Gemini-path usages used `input_tokens` /
-// `output_tokens`. Normalize both so aggregation never produces NaN.
-function inTok(u) {
-    return (u.input_tokens ?? u.prompt_tokens ?? 0);
-}
-function outTok(u) {
-    return (u.output_tokens ?? u.completion_tokens ?? 0);
-}
-function cachedTok(u) {
-    return (u.cached_input_tokens ?? u.prompt_tokens_details?.cached_tokens ?? 0);
-}
-function estimateCost(usage) {
-    const model = usage.model;
-    // Default to gemini-2.5-flash pricing if unknown
-    const pricing = exports.PRICING[model] || exports.PRICING['gemini-2.5-flash'];
-    const inputCost = (inTok(usage) / 1000000) * pricing.inputPricePerM;
-    const outputCost = (outTok(usage) / 1000000) * pricing.outputPricePerM;
-    const cachedCost = (cachedTok(usage) / 1000000) * pricing.cachedInputPricePerM;
-    return inputCost + outputCost + cachedCost;
-}
+// The CLI emits the vLLM/OpenAI shape (`prompt_tokens`); older rows used `input_tokens`.
+const inTok = (u) => (u.input_tokens ?? u.prompt_tokens ?? 0);
+const outTok = (u) => (u.output_tokens ?? u.completion_tokens ?? 0);
+const cachedTok = (u) => (u.cached_input_tokens ?? u.prompt_tokens_details?.cached_tokens ?? 0);
+/** One summed row for a solve. The client has no price list, so `estimatedCost` is always 0. */
 function aggregateTokenUsage(usages) {
-    if (usages.length === 0) {
-        return {
-            modelName: 'none',
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedInputTokens: 0,
-            estimatedCost: 0,
-        };
-    }
-    const modelName = usages[0].model;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cachedInputTokens = 0;
-    let estimatedCost = 0;
-    for (const usage of usages) {
-        inputTokens += inTok(usage);
-        outputTokens += outTok(usage);
-        cachedInputTokens += cachedTok(usage);
-        estimatedCost += estimateCost(usage);
-    }
     return {
-        modelName,
-        inputTokens,
-        outputTokens,
-        cachedInputTokens,
-        estimatedCost,
+        modelName: usages[0]?.model ?? 'none',
+        inputTokens: usages.reduce((n, u) => n + inTok(u), 0),
+        outputTokens: usages.reduce((n, u) => n + outTok(u), 0),
+        cachedInputTokens: usages.reduce((n, u) => n + cachedTok(u), 0),
+        estimatedCost: 0,
     };
 }