@wix/pathgrade 1.0.32 → 1.0.33

package/dist/agents/codex-app-server/agent.js

@@ -17,6 +17,7 @@ import { CodexItemLifecycle, } from './item-lifecycle.js';
 import { createCodexManagedAuth } from './managed-auth.js';
 import { clearTurnAuthorityDeadline, closeUncorrelatedTurnTransport, establishAuthoritativeTurn, isAbortError, isAuthoritativeTurnCompletion, rememberAuthoritativeTurnId, shouldRetireAuthoritativeTurnTransport, } from './turn-authority.js';
 import { dispatchCodexNotification, failTurn } from './turn-notifications.js';
+import { CodexThreadCostAccounting, CodexTurnUsageAccounting, readCodexThreadCost, } from './usage-accounting.js';
 const TURN_COMPLETED_METHOD = 'turn/completed';
 function recordFromUnknown(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -74,6 +75,7 @@ export class CodexAppServerAgent extends BaseAgent {
         let disposed = false;
         let sessionRetired = false;
         let codexUserAgent = 'unknown';
+        const costAccounting = new CodexThreadCostAccounting();
         const managedAuth = createCodexManagedAuth({
             enabled: !runtimeEnv.OPENAI_API_KEY && !runtimeEnv.OPENAI_BASE_URL
                 && (this.deps.authBroker !== undefined || this.deps.createTransport === undefined),
@@ -165,6 +167,7 @@ export class CodexAppServerAgent extends BaseAgent {
                 assistantMessageParts: [],
                 turnFailed: false,
                 pendingTurnCompletions: [],
+                usageAccounting: new CodexTurnUsageAccounting(),
             };
             const turnStartController = new AbortController();
             let turnStartCanReuseTransport = false;
@@ -196,6 +199,7 @@ export class CodexAppServerAgent extends BaseAgent {
                         throw new Error(`Codex app-server scripted MCP approval policy drift (userAgent=${codexUserAgent})`);
                     }
                     threadId = resp.thread.id;
+                    costAccounting.beginThread(threadId);
                 }
                 const authoritativeThreadId = threadId;
                 turn.authoritativeThreadId = authoritativeThreadId;
@@ -224,14 +228,20 @@ export class CodexAppServerAgent extends BaseAgent {
                 const authoritativeTurnReady = new Promise((resolve) => {
                     resolveAuthoritativeTurn = resolve;
                 });
-                const markAuthoritativeTurn = (candidateTurnId) => establishAuthoritativeTurn({
-                    turn,
-                    candidateTurnId,
-                    authoritativeThreadId,
-                    authoritativeTurnIds,
-                    correlator,
-                    onReady: () => resolveAuthoritativeTurn?.(),
-                });
+                const markAuthoritativeTurn = (candidateTurnId) => {
+                    const established = establishAuthoritativeTurn({
+                        turn,
+                        candidateTurnId,
+                        authoritativeThreadId,
+                        authoritativeTurnIds,
+                        correlator,
+                        onReady: () => resolveAuthoritativeTurn?.(),
+                    });
+                    if (established)
+                        turn.usageAccounting.authorize(authoritativeThreadId, candidateTurnId);
+                    return established;
+                };
+                let terminalCompletionAccepted = false;
                 const turnCompletion = new Promise((resolve, reject) => {
                     let settled = false;
                     const off = t.onNotification((n) => {
@@ -253,6 +263,7 @@ export class CodexAppServerAgent extends BaseAgent {
                         }))
                             return;
                         settled = true;
+                        terminalCompletionAccepted = true;
                         off();
                         closeOff();
                         const failure = extractTurnCompletionFailure(params);
@@ -350,6 +361,9 @@ export class CodexAppServerAgent extends BaseAgent {
                         sensitiveValues, resolvedModel: model,
                     });
                 }
+                if (terminalCompletionAccepted) {
+                    turn.costUsd = await readCodexThreadCost(t, authoritativeThreadId, costAccounting, options?.getRemainingMs);
+                }
                 if (turn.turnFailed) {
                     return assembleTurnResult({
                         askBus,
@@ -592,6 +606,8 @@ function assembleTurnResult(args) {
         exitCode,
         traceOutput: rawOutput,
         toolEvents, resolvedModel,
+        ...activeTurn.usageAccounting.result(),
+        ...(activeTurn.costUsd === undefined ? {} : { costUsd: activeTurn.costUsd }),
         ...(exitCode !== 0
             ? {
                 crashInfo: {

package/dist/agents/codex-app-server/protocol/ClientRequest.d.ts

@@ -1,5 +1,5 @@
 /**
- * The 8 client-request methods the pathgrade driver may send to the Codex
+ * The 9 client-request methods the pathgrade driver may send to the Codex
  * app-server. Scoped to this driver's surface rather than the full upstream
  * protocol; phantom response-shaped entries are deliberately excluded because
  * JSON-RPC responses to server-initiated requests flow through
@@ -13,8 +13,9 @@
  * - thread/read
  * - thread/list
  * - review/start
+ * - account/usage/read
  */
-export type ClientRequestMethod = 'initialize' | 'thread/start' | 'turn/start' | 'turn/interrupt' | 'thread/inject_items' | 'thread/read' | 'thread/list' | 'review/start';
+export type ClientRequestMethod = 'initialize' | 'thread/start' | 'turn/start' | 'turn/interrupt' | 'thread/inject_items' | 'thread/read' | 'thread/list' | 'review/start' | 'account/usage/read';
 /**
  * JSON-RPC 2.0 client→server request envelope the driver constructs.
  * Generic over the params type for the chosen method.

package/dist/agents/codex-app-server/protocol/GetAccountTokenUsageParams.d.ts

@@ -0,0 +1,3 @@
+export type GetAccountTokenUsageParams = {
+    threadId?: string | null;
+};

package/dist/agents/codex-app-server/protocol/GetAccountTokenUsageParams.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/GetAccountTokenUsageParams.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/GetAccountTokenUsageResponse.d.ts

@@ -0,0 +1,6 @@
+import type { ThreadUsage } from './ThreadUsage.js';
+export type GetAccountTokenUsageResponse = {
+    summary: unknown;
+    dailyUsageBuckets: unknown[] | null;
+    threadUsage?: ThreadUsage | null;
+};

package/dist/agents/codex-app-server/protocol/GetAccountTokenUsageResponse.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/GetAccountTokenUsageResponse.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/ThreadTokenUsage.d.ts

@@ -0,0 +1,6 @@
+import type { TokenUsageBreakdown } from './TokenUsageBreakdown.js';
+export type ThreadTokenUsage = {
+    total: TokenUsageBreakdown;
+    last: TokenUsageBreakdown;
+    modelContextWindow: number | null;
+};

package/dist/agents/codex-app-server/protocol/ThreadTokenUsage.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/ThreadTokenUsage.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/ThreadTokenUsageUpdatedNotification.d.ts

@@ -0,0 +1,6 @@
+import type { ThreadTokenUsage } from './ThreadTokenUsage.js';
+export type ThreadTokenUsageUpdatedNotification = {
+    threadId: string;
+    turnId: string;
+    tokenUsage: ThreadTokenUsage;
+};

package/dist/agents/codex-app-server/protocol/ThreadTokenUsageUpdatedNotification.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/ThreadTokenUsageUpdatedNotification.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/ThreadUsage.d.ts

@@ -0,0 +1,7 @@
+import type { ThreadUsageBreakdownGroup } from './ThreadUsageBreakdownGroup.js';
+export type ThreadUsage = {
+    threadId: string;
+    estimatedUsageCreditsMicros: bigint;
+    estimatedUsageUsdMicros: bigint | null;
+    groups: ThreadUsageBreakdownGroup[];
+};

package/dist/agents/codex-app-server/protocol/ThreadUsage.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/ThreadUsage.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/ThreadUsageBreakdownGroup.d.ts

@@ -0,0 +1,11 @@
+export type ThreadUsageBreakdownGroup = {
+    model: string | null;
+    reasoningEffort: string | null;
+    speed: string | null;
+    estimatedUsageCreditsMicros: bigint;
+    netNewInputTokens: bigint | null;
+    cachedInputTokens: bigint | null;
+    inputTokens: bigint | null;
+    outputTokens: bigint | null;
+    totalTokens: bigint | null;
+};

package/dist/agents/codex-app-server/protocol/ThreadUsageBreakdownGroup.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/ThreadUsageBreakdownGroup.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/TokenUsageBreakdown.d.ts

@@ -0,0 +1,8 @@
+export type TokenUsageBreakdown = {
+    totalTokens: number;
+    inputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+};

package/dist/agents/codex-app-server/protocol/TokenUsageBreakdown.js

@@ -0,0 +1,4 @@
+// Vendored from openai/codex@rust-v0.149.0-alpha.4.3
+// Source: codex-rs/app-server-protocol/schema/typescript/v2/TokenUsageBreakdown.ts
+// GENERATED CODE in upstream; do not modify locally either.
+export {};

package/dist/agents/codex-app-server/protocol/index.d.ts

@@ -14,3 +14,10 @@ export type { McpElicitationRequestParams } from './McpElicitationRequestParams.
 export type { ThreadStartParams } from './ThreadStartParams.js';
 export type { SandboxMode } from './SandboxMode.js';
 export type { TurnCompletedNotification } from './TurnCompletedNotification.js';
+export type { TokenUsageBreakdown } from './TokenUsageBreakdown.js';
+export type { ThreadTokenUsage } from './ThreadTokenUsage.js';
+export type { ThreadTokenUsageUpdatedNotification } from './ThreadTokenUsageUpdatedNotification.js';
+export type { ThreadUsageBreakdownGroup } from './ThreadUsageBreakdownGroup.js';
+export type { ThreadUsage } from './ThreadUsage.js';
+export type { GetAccountTokenUsageParams } from './GetAccountTokenUsageParams.js';
+export type { GetAccountTokenUsageResponse } from './GetAccountTokenUsageResponse.js';

package/dist/agents/codex-app-server/turn-notifications.js

@@ -12,6 +12,10 @@ export function dispatchCodexNotification(notification, turn, sensitiveValues) {
     }
     if (!turn)
         return;
+    if (notification.method === 'thread/tokenUsage/updated') {
+        turn.usageAccounting.receive(notification.params, turn.authoritativeThreadId, turn.authoritativeTurnId);
+        return;
+    }
     const params = notification.params;
     if (notification.method === 'item/started') {
         if (params)

package/dist/agents/codex-app-server/turn-state.d.ts

@@ -1,6 +1,7 @@
 import type { ToolEvent } from '../../tool-events.js';
 import type { PendingMcpDenial } from './mcp-approval-correlator.js';
 import type { CodexItemLifecycle } from './item-lifecycle.js';
+import type { CodexTurnUsageAccounting } from './usage-accounting.js';
 export interface ActiveTurnState {
     turnNumber: number;
     askBatchIds: string[];
@@ -14,6 +15,8 @@ export interface ActiveTurnState {
     authoritativeThreadId?: string;
     authoritativeTurnId?: string;
     pendingTurnCompletions: unknown[];
+    usageAccounting: CodexTurnUsageAccounting;
+    costUsd?: number;
     acceptTurnCompletion?: (params: unknown) => void;
     authorityDeadlineTimer?: ReturnType<typeof setTimeout>;
 }

package/dist/agents/codex-app-server/usage-accounting.d.ts

@@ -0,0 +1,18 @@
+import type { AgentTurnResult } from '../../types.js';
+import type { AppServerTransport } from './transport.js';
+export declare const WIX_CODEX_USD_PER_CREDIT = 0.034;
+export declare class CodexTurnUsageAccounting {
+    private baseline?;
+    private latest?;
+    private pending;
+    authorize(threadId: string, turnId: string): void;
+    receive(value: unknown, threadId: string | undefined, turnId: string | undefined): void;
+    result(): Pick<AgentTurnResult, 'inputTokens' | 'outputTokens' | 'cacheReadInputTokens' | 'cacheCreationInputTokens'>;
+}
+export declare class CodexThreadCostAccounting {
+    private threadId?;
+    private cumulativeUsd;
+    beginThread(threadId: string): void;
+    receive(value: unknown, threadId: string): number | undefined;
+}
+export declare function readCodexThreadCost(transport: AppServerTransport, threadId: string, accounting: CodexThreadCostAccounting, getRemainingMs?: () => number): Promise<number | undefined>;

package/dist/agents/codex-app-server/usage-accounting.js

@@ -0,0 +1,121 @@
+const TOKEN_KEYS = [
+    'totalTokens', 'inputTokens', 'cachedInputTokens',
+    'cacheWriteInputTokens', 'outputTokens', 'reasoningOutputTokens',
+];
+export const WIX_CODEX_USD_PER_CREDIT = 0.034;
+const USAGE_READ_FALLBACK_TIMEOUT_MS = 5_000;
+export class CodexTurnUsageAccounting {
+    baseline;
+    latest;
+    pending = [];
+    authorize(threadId, turnId) {
+        for (const value of this.pending.splice(0))
+            this.receive(value, threadId, turnId);
+    }
+    receive(value, threadId, turnId) {
+        const params = record(value);
+        if (threadId && !turnId) {
+            if (this.pending.length < 64)
+                this.pending.push(value);
+            return;
+        }
+        if (!threadId || !turnId || params?.threadId !== threadId || params.turnId !== turnId)
+            return;
+        const tokenUsage = record(params.tokenUsage);
+        const total = counters(tokenUsage?.total);
+        const last = counters(tokenUsage?.last);
+        if (!total || !last || !atLeast(total, last))
+            return;
+        if (!this.baseline) {
+            this.baseline = subtract(total, last);
+            this.latest = total;
+            return;
+        }
+        if (this.latest && !atLeast(total, this.latest))
+            return;
+        this.latest = total;
+    }
+    result() {
+        if (!this.baseline || !this.latest)
+            return {};
+        return {
+            inputTokens: this.latest.inputTokens - this.baseline.inputTokens,
+            outputTokens: this.latest.outputTokens - this.baseline.outputTokens,
+            cacheReadInputTokens: this.latest.cachedInputTokens - this.baseline.cachedInputTokens,
+            cacheCreationInputTokens: this.latest.cacheWriteInputTokens - this.baseline.cacheWriteInputTokens,
+        };
+    }
+}
+export class CodexThreadCostAccounting {
+    threadId;
+    cumulativeUsd = 0;
+    beginThread(threadId) {
+        if (this.threadId === threadId)
+            return;
+        this.threadId = threadId;
+        this.cumulativeUsd = 0;
+    }
+    receive(value, threadId) {
+        const response = record(value);
+        const usage = record(response?.threadUsage);
+        if (!usage || usage.threadId !== threadId || this.threadId !== threadId)
+            return undefined;
+        const usdValue = usage.estimatedUsageUsdMicros;
+        const current = usdValue !== undefined && usdValue !== null
+            ? microsToUsd(usdValue)
+            : creditsToUsd(usage.estimatedUsageCreditsMicros);
+        if (current === undefined || current < this.cumulativeUsd)
+            return undefined;
+        const delta = current - this.cumulativeUsd;
+        this.cumulativeUsd = current;
+        return delta;
+    }
+}
+export async function readCodexThreadCost(transport, threadId, accounting, getRemainingMs) {
+    const remainingMs = getRemainingMs?.() ?? USAGE_READ_FALLBACK_TIMEOUT_MS;
+    if (remainingMs <= 0)
+        return undefined;
+    const controller = new AbortController();
+    const timer = Number.isFinite(remainingMs) ? setTimeout(() => controller.abort(), remainingMs) : undefined;
+    try {
+        const response = await transport.sendRequest('account/usage/read', { threadId }, {
+            signal: controller.signal,
+        });
+        return accounting.receive(response, threadId);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function counters(value) {
+    const source = record(value);
+    if (!source || !TOKEN_KEYS.every(key => Number.isSafeInteger(source[key]) && source[key] >= 0))
+        return undefined;
+    return Object.fromEntries(TOKEN_KEYS.map(key => [key, source[key]]));
+}
+function atLeast(value, floor) {
+    return TOKEN_KEYS.every(key => value[key] >= floor[key]);
+}
+function subtract(value, amount) {
+    return Object.fromEntries(TOKEN_KEYS.map(key => [key, value[key] - amount[key]]));
+}
+function optionalMicros(value) {
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function microsToUsd(value) {
+    const micros = optionalMicros(value);
+    return micros === undefined ? undefined : micros / 1_000_000;
+}
+function creditsToUsd(value) {
+    const micros = optionalMicros(value);
+    return micros === undefined ? undefined : micros / 1_000_000 * WIX_CODEX_USD_PER_CREDIT;
+}

package/dist/openai-oauth/chatgpt-oauth-llm.js

@@ -342,12 +342,23 @@ export function createChatGptOAuthJudgeLLMWithDependencies(options, dependencies
             throw oauthError('OAUTH_PROTOCOL_RESPONSE_INVALID');
         }
     };
+    let costUsd = 0;
+    let costObserved = false;
     const port = {
         get tokenUsage() { return { inputTokens, outputTokens }; },
+        get costUsd() { return costUsd; },
+        get costObserved() { return costObserved; },
+        addCost(usd) {
+            if (!Number.isFinite(usd) || usd < 0)
+                return;
+            costUsd += usd;
+            costObserved = true;
+        },
         get supportsToolUse() { return true; },
         async measure(fn) {
             const beforeInput = inputTokens;
             const beforeOutput = outputTokens;
+            const beforeCost = costUsd;
             const result = await fn();
             return {
                 result,
@@ -355,7 +366,7 @@ export function createChatGptOAuthJudgeLLMWithDependencies(options, dependencies
                     inputTokens: inputTokens - beforeInput,
                     outputTokens: outputTokens - beforeOutput,
                 },
-                costUsd: 0,
+                costUsd: costUsd - beforeCost,
             };
         },
         async call(prompt, callOptions = {}) {

package/dist/sdk/agent.js

@@ -261,9 +261,7 @@ class AgentImpl {
         const sendTurn = async (message) => {
             const turnResult = await ms.executeTurn(message);
             turnNumber++;
-            // Accumulate agent turn tokens (from CLI stream-json) on the shared tracker.
-            // Cost is populated by Claude SDK (from `total_cost_usd`); Codex/Cursor leave
-            // it undefined, in which case this is a no-op.
+            // Accumulate provider-reported agent turn tokens and cost on the shared tracker.
             this.accumulateTurnUsage(turnResult);
             for (const toolEvent of turnResult.toolEvents) {
                 this._log.push(buildToolEventLogEntry(toolEvent, new Date().toISOString()));

package/dist/sdk/evaluate.js

@@ -68,8 +68,9 @@ function makeEvaluateAgent() {
             : undefined;
         // Agent usage is independent of the optional scorer LLM. Same
         // first-eval attribution rule for cost; omit it when unavailable.
-        // no conversation cost was captured (Codex / Cursor today).
-        const conversationCost = isFirstEval && beforeCostUsd > 0
+        // Preserve an authoritative zero while retaining compatibility with
+        // older/custom ports whose positive total is the only presence signal.
+        const conversationCost = isFirstEval && (agent.llm.costObserved === true || beforeCostUsd > 0)
             ? { conversation_cost_usd: beforeCostUsd }
             : undefined;
         if (isFirstEval)

package/dist/sdk/lifecycle.js

@@ -140,6 +140,7 @@ function synthesizeTrialFromAgent(agent) {
         return null;
     const nCommands = countShellCommandsFromLog(agent.log);
     const tokenUsage = agent.llm.tokenUsage;
+    const conversationCostUsd = agent.llm.costUsd ?? 0;
     const conversationEnd = [...agent.log].reverse().find((entry) => entry.type === 'conversation_end');
     const completionReason = conversationEnd?.completion_reason ?? (agent.log.some((entry) => entry.type === 'agent_result') ? 'completed' : undefined);
     return {
@@ -160,6 +161,9 @@ function synthesizeTrialFromAgent(agent) {
                     conversation_output_tokens: tokenUsage.outputTokens,
                 }
                 : {}),
+            ...(agent.llm.costObserved === true || conversationCostUsd > 0
+                ? { conversation_cost_usd: conversationCostUsd }
+                : {}),
             session_log: [...agent.log],
         },
         diagnostics: buildDiagnosticsReport({

package/dist/types.d.ts

@@ -85,8 +85,7 @@ export interface LogEntry {
     blocked_prompt_tool_use_id?: string;
     runtime_policies_applied?: RuntimePolicyDescriptor[];
     /**
-     * Per-turn agent cost in USD when the upstream provider reports it (the
-     * Claude Agent SDK populates `total_cost_usd` on result messages).
+     * Per-turn agent cost in USD when the executing agent reports or estimates it.
      * Written by `buildModelAgentResultLogEntry` only when the turn result
      * carries a `costUsd` value; absent for agents that do not expose cost.
      */
@@ -332,10 +331,7 @@ export interface AgentTurnResult {
      */
     cacheReadInputTokens?: number;
     /**
-     * Optional turn cost in USD reported by providers that expose exact
-     * pricing. The Claude Agent SDK populates this from the result
-     * message's `total_cost_usd`. Other drivers (Codex, Cursor) leave it
-     * undefined until their providers expose comparable metadata.
+     * Optional turn cost in USD reported or estimated by the executing agent.
      */
     costUsd?: number;
     /**

package/dist/utils/llm-mocks.js

@@ -12,6 +12,7 @@ export function createMockLLM(opts = {}) {
     let inputTokens = 0;
     let outputTokens = 0;
     let costUsd = 0;
+    let costObserved = false;
     let callCount = 0;
     const take = () => {
         callCount++;
@@ -29,6 +30,9 @@ export function createMockLLM(opts = {}) {
         get costUsd() {
             return costUsd;
         },
+        get costObserved() {
+            return costObserved;
+        },
         get supportsToolUse() {
             return true;
         },
@@ -43,6 +47,7 @@ export function createMockLLM(opts = {}) {
             if (!Number.isFinite(usd) || usd < 0)
                 return;
             costUsd += usd;
+            costObserved = true;
         },
         async measure(fn) {
             const inBefore = inputTokens;

package/dist/utils/llm-types.d.ts

@@ -32,9 +32,11 @@ export interface LLMPort {
      * comparable metadata.
      */
     readonly costUsd?: number;
+    /** True after any valid cost observation, including an observed zero. */
+    readonly costObserved?: boolean;
     /** Add externally-observed tokens (e.g. from agent CLI turns). */
     addTokens?(input: number, output: number): void;
-    /** Add externally-observed cost (e.g. from Claude SDK `total_cost_usd`). */
+    /** Add externally-observed agent cost. */
     addCost?(usd: number): void;
     /** Run `fn` and return its token + cost delta. */
     measure?<T>(fn: () => Promise<T>): Promise<{

package/dist/utils/llm.js

@@ -45,6 +45,7 @@ export function createLLMClient(arg, legacyAgentName) {
     let inputTokens = 0;
     let outputTokens = 0;
     let costUsd = 0;
+    let costObserved = false;
     let lastProvider;
     const warnFallthrough = (from, to, reason) => {
         if (silent)
@@ -67,6 +68,9 @@ export function createLLMClient(arg, legacyAgentName) {
         get costUsd() {
             return costUsd;
         },
+        get costObserved() {
+            return costObserved;
+        },
         get supportsToolUse() {
             return !!toolCapable;
         },
@@ -84,6 +88,7 @@ export function createLLMClient(arg, legacyAgentName) {
             if (!Number.isFinite(usd) || usd < 0)
                 return;
             costUsd += usd;
+            costObserved = true;
         },
         async measure(fn) {
             const inBefore = inputTokens;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -140,5 +140,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "c7a69bbfe306a62f3d89b21d92a09f18996516cd374f1772d1181d3f"
+  "falconPackageHash": "044358f11c1feb83b7e0a5b40972dd14eaf2c5b0d1261ba1339cf9d2"
 }