@juspay/neurolink 11.11.7 → 11.13.0

package/dist/lib/providers/googleVertex/client.js

@@ -11,7 +11,7 @@ import { DEFAULT_GEMINI_STREAM_TIMEOUT_MS, DEFAULT_MAX_STEPS, DEFAULT_TOOL_EXECU
 import { ModelConfigurationManager } from "../../core/modelConfiguration.js";
 import { isSchemaComplexityError } from "../../core/modules/structuredOutputPolicy.js";
 import { redactUrlForError, stringifyContentSafe, } from "../../utils/logSanitize.js";
-import { createProxyFetch } from "../../proxy/proxyFetch.js";
+import { warnGoogleSdkIgnoresProxy } from "../../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
@@ -578,6 +578,27 @@ function reclaimVertexAnthropicContext(messages, modelName, observedPromptTokens
 export class GoogleVertexProvider extends BaseProvider {
     projectId;
     location;
+    /**
+     * Vertex AI Express Mode credentials.
+     *
+     * Vertex supports two authentication modes. The long-standing one pairs a
+     * project and location with Application Default Credentials, which makes
+     * the SDK mint an OAuth token through google-auth-library before every
+     * request. Express Mode instead authenticates with an API key alone.
+     *
+     * Express is used only when an apiKey is supplied WITHOUT an explicit
+     * project or location, so existing ADC callers — including those already
+     * passing an apiKey alongside a project — keep exactly the behaviour they
+     * have today.
+     */
+    expressApiKey;
+    /**
+     * Optional endpoint override, mirroring AI Studio's
+     * `credentials.googleAiStudio.baseURL`: per-request credential first, then
+     * the environment, then unset so the SDK applies its own default. Blank
+     * values count as unset so an empty override cannot clobber that default.
+     */
+    baseURL;
     registeredTools = new Map();
     toolContext = {};
     // Memory-managed cache for model configuration lookups to avoid repeated calls
@@ -601,14 +622,33 @@ export class GoogleVertexProvider extends BaseProvider {
             }
             if (credentials.apiKey) {
                 process.env.GOOGLE_API_KEY = String(credentials.apiKey);
+                // Express Mode only when the caller gave a key and NOTHING else to
+                // authenticate with. An apiKey passed next to a project is the
+                // pre-existing combination and must keep resolving through ADC.
+                if (!credentials.projectId && !credentials.location) {
+                    this.expressApiKey = String(credentials.apiKey);
+                }
+            }
+            if (credentials.baseURL) {
+                this.baseURL = String(credentials.baseURL);
             }
         }
-        // Validate Google Cloud credentials - now using consolidated utility
-        if (!hasGoogleCredentials()) {
-            validateApiKey(createGoogleAuthConfig());
+        // Express Mode authenticates with the key alone, so neither the ADC
+        // credential check nor project resolution applies. Both THROW when
+        // nothing is configured, which would fail an apiKey-only request before
+        // the Express client is ever built — and would do so only on machines
+        // without an ambient project, which is exactly where Express is the point.
+        const usingExpress = Boolean(this.resolveExpressApiKey());
+        if (!usingExpress) {
+            // Validate Google Cloud credentials - now using consolidated utility
+            if (!hasGoogleCredentials()) {
+                validateApiKey(createGoogleAuthConfig());
+            }
         }
         // Initialize Google Cloud configuration
-        this.projectId = credentials?.projectId || getVertexProjectId();
+        this.projectId =
+            credentials?.projectId ||
+                (usingExpress ? "" : getVertexProjectId());
         this.location =
             region || credentials?.location || getVertexLocation();
         logger.debug("[GoogleVertexProvider] Constructor initialized", {
@@ -803,7 +843,11 @@ export class GoogleVertexProvider extends BaseProvider {
      * Create @google/genai client configured for Vertex AI
      */
     async createVertexGenAIClient(regionOverride) {
-        const project = getVertexProjectId();
+        warnGoogleSdkIgnoresProxy("GoogleVertex");
+        const expressApiKey = this.resolveExpressApiKey();
+        // Resolved only on the ADC path: getVertexProjectId() throws when no
+        // project is configured, which an Express request legitimately has none of.
+        const project = expressApiKey ? "" : getVertexProjectId();
         const location = regionOverride || this.location || getVertexLocation();
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
@@ -818,17 +862,72 @@ export class GoogleVertexProvider extends BaseProvider {
             });
         }
         const Ctor = ctor;
-        // Use vertexai mode with project and location
-        // Include httpOptions with proxy fetch for corporate network support
+        const baseUrl = this.resolveBaseURL();
+        const httpOptions = {
+            // The endpoint override and nothing else. This object used to also pass
+            // a proxy fetch, which the SDK silently ignored — see
+            // warnGoogleSdkIgnoresProxy for why that is not fixable here.
+            //
+            // Only set when resolved: the SDK falls back to its own default
+            // whenever httpOptions.baseUrl is undefined, so omitting the key and
+            // passing undefined behave identically.
+            ...(baseUrl ? { baseUrl } : {}),
+        };
+        if (expressApiKey) {
+            // Express Mode: an API key replaces project/location entirely. Passing
+            // them alongside the key would defeat it — the SDK prefers
+            // project/location and falls back to ADC, which is the very thing
+            // Express exists to avoid.
+            return new Ctor({
+                vertexai: true,
+                apiKey: expressApiKey,
+                httpOptions,
+            });
+        }
+        // Project/location mode, authenticating through ADC.
         return new Ctor({
             vertexai: true,
             project,
             location,
-            httpOptions: {
-                fetch: createProxyFetch(),
-            },
+            httpOptions,
         });
     }
+    /** Endpoint override: credential, then environment, then unset. */
+    resolveBaseURL() {
+        const resolved = this.baseURL?.trim() || process.env.GOOGLE_VERTEX_BASE_URL?.trim();
+        return resolved && resolved.length > 0 ? resolved : undefined;
+    }
+    /**
+     * Express Mode key, if this provider should use it.
+     *
+     * Deliberately NOT read from GOOGLE_API_KEY: that variable is already set
+     * by callers who also configure a project, and treating it as an Express
+     * opt-in would silently switch their authentication mode. Express is opted
+     * into per request, or through GOOGLE_VERTEX_API_KEY which exists only for
+     * this purpose.
+     */
+    resolveExpressApiKey() {
+        // A per-request key already carries its own guard: it is only recorded
+        // when the caller supplied no project and no location.
+        const fromCredentials = this.expressApiKey?.trim();
+        if (fromCredentials) {
+            return fromCredentials;
+        }
+        const fromEnv = process.env.GOOGLE_VERTEX_API_KEY?.trim();
+        if (!fromEnv) {
+            return undefined;
+        }
+        // The environment key gets the same guard. A process that configures a
+        // project has an ADC setup, and letting an ambient key silently switch it
+        // to Express would change how that process authenticates.
+        const projectConfigured = [
+            "GOOGLE_CLOUD_PROJECT_ID",
+            "VERTEX_PROJECT_ID",
+            "GOOGLE_VERTEX_PROJECT",
+            "GOOGLE_CLOUD_PROJECT",
+        ].some((name) => (process.env[name] ?? "").trim().length > 0);
+        return projectConfigured ? undefined : fromEnv;
+    }
     /**
      * Convert one AI-SDK tool into a Vertex Gemini function declaration.
      * Single source for the pre-loop snapshot AND the mid-turn discovery

package/dist/lib/proxy/codexUsage.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Codex (OpenAI Responses) SSE usage tap.
+ *
+ * The Codex proxy engine relays `upstream.body` to the client untouched and
+ * logs before a single byte is read, so no Codex request has ever carried token
+ * counts. This module adds a pass-through tap that scrapes `usage` out of the
+ * stream without holding back or altering any bytes.
+ *
+ * ## Safety contract
+ *
+ * This sits in the hot path of a live proxy, so it is built to be incapable of
+ * breaking a stream:
+ *
+ * - every chunk is enqueued **before** it is inspected;
+ * - all parsing runs inside try/catch, and a throw is swallowed;
+ * - a stream whose shape is unrecognised resolves `usage` to `null`, which is
+ *   exactly today's behaviour (a log with no token fields).
+ *
+ * The worst case is therefore "no tokens recorded", never a truncated or
+ * corrupted response.
+ *
+ * ## Wire shape
+ *
+ * **Verified against real traffic.** Captured from a live `codex exec` run
+ * through the proxy on 2026-08-21; the trimmed sample is at
+ * `test/fixtures/codex-response-usage.sse` and is asserted against in the
+ * codex suite. The real shape is
+ *
+ *   event: response.completed
+ *   data: {"type":"response.completed","response":{"usage":{
+ *     "input_tokens":N,"output_tokens":M,
+ *     "input_tokens_details":{"cached_tokens":K,"cache_write_tokens":W},
+ *     "output_tokens_details":{"reasoning_tokens":R}}}}
+ *
+ * Note that `response.created` arrives first carrying `usage: null`, which is
+ * why the scanner keeps the last non-null result rather than the first.
+ *
+ * It also accepts a `usage` object at the top level of any event and the
+ * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
+ * observed", never "zero tokens".
+ */
+import type { CodexStreamUsage } from "../types/index.js";
+/**
+ * Pull usage out of one parsed SSE `data:` payload.
+ *
+ * Returns null when the payload carries no recognisable usage object, so the
+ * caller can keep the last non-null result rather than overwriting it with a
+ * later event that happens not to carry usage.
+ */
+export declare function extractCodexUsage(payload: unknown): CodexStreamUsage | null;
+/**
+ * Scan a slice of SSE text for usage, returning the last one found.
+ *
+ * Exported for tests: it is the whole parsing decision, and driving it through
+ * a real Codex stream would need a live ChatGPT subscription.
+ */
+export declare function scanCodexSSEForUsage(text: string): CodexStreamUsage | null;
+/**
+ * A pass-through TransformStream that reports the usage seen on a Codex SSE
+ * stream.
+ *
+ * `usage` resolves when the stream ends: to the last usage observed, or null if
+ * none was. It never rejects.
+ */
+export declare function createCodexUsageTap(): {
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    usage: Promise<CodexStreamUsage | null>;
+};

package/dist/lib/proxy/codexUsage.js

@@ -0,0 +1,247 @@
+/**
+ * Codex (OpenAI Responses) SSE usage tap.
+ *
+ * The Codex proxy engine relays `upstream.body` to the client untouched and
+ * logs before a single byte is read, so no Codex request has ever carried token
+ * counts. This module adds a pass-through tap that scrapes `usage` out of the
+ * stream without holding back or altering any bytes.
+ *
+ * ## Safety contract
+ *
+ * This sits in the hot path of a live proxy, so it is built to be incapable of
+ * breaking a stream:
+ *
+ * - every chunk is enqueued **before** it is inspected;
+ * - all parsing runs inside try/catch, and a throw is swallowed;
+ * - a stream whose shape is unrecognised resolves `usage` to `null`, which is
+ *   exactly today's behaviour (a log with no token fields).
+ *
+ * The worst case is therefore "no tokens recorded", never a truncated or
+ * corrupted response.
+ *
+ * ## Wire shape
+ *
+ * **Verified against real traffic.** Captured from a live `codex exec` run
+ * through the proxy on 2026-08-21; the trimmed sample is at
+ * `test/fixtures/codex-response-usage.sse` and is asserted against in the
+ * codex suite. The real shape is
+ *
+ *   event: response.completed
+ *   data: {"type":"response.completed","response":{"usage":{
+ *     "input_tokens":N,"output_tokens":M,
+ *     "input_tokens_details":{"cached_tokens":K,"cache_write_tokens":W},
+ *     "output_tokens_details":{"reasoning_tokens":R}}}}
+ *
+ * Note that `response.created` arrives first carrying `usage: null`, which is
+ * why the scanner keeps the last non-null result rather than the first.
+ *
+ * It also accepts a `usage` object at the top level of any event and the
+ * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
+ * observed", never "zero tokens".
+ */
+import { appendFileSync } from "node:fs";
+const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : 0;
+/**
+ * Pull usage out of one parsed SSE `data:` payload.
+ *
+ * Returns null when the payload carries no recognisable usage object, so the
+ * caller can keep the last non-null result rather than overwriting it with a
+ * later event that happens not to carry usage.
+ */
+export function extractCodexUsage(payload) {
+    if (payload === null || typeof payload !== "object") {
+        return null;
+    }
+    const root = payload;
+    const response = root.response;
+    const usage = (response && typeof response === "object" && response.usage
+        ? response.usage
+        : root.usage);
+    if (!usage || typeof usage !== "object") {
+        return null;
+    }
+    const input = usage.input_tokens ?? usage.prompt_tokens;
+    const output = usage.output_tokens ?? usage.completion_tokens;
+    if (input === undefined && output === undefined) {
+        return null;
+    }
+    const inputDetails = usage.input_tokens_details;
+    const outputDetails = usage.output_tokens_details;
+    return {
+        inputTokens: nonNegativeInt(input),
+        outputTokens: nonNegativeInt(output),
+        cacheReadTokens: nonNegativeInt(inputDetails?.cached_tokens),
+        cacheCreationTokens: nonNegativeInt(inputDetails?.cache_write_tokens),
+        reasoningTokens: nonNegativeInt(outputDetails?.reasoning_tokens),
+    };
+}
+/**
+ * Scan a slice of SSE text for usage, returning the last one found.
+ *
+ * Exported for tests: it is the whole parsing decision, and driving it through
+ * a real Codex stream would need a live ChatGPT subscription.
+ */
+export function scanCodexSSEForUsage(text) {
+    let found = null;
+    for (const line of text.split("\n")) {
+        if (!line.startsWith("data:")) {
+            continue;
+        }
+        const raw = line.slice(5).trim();
+        if (!raw || raw === "[DONE]") {
+            continue;
+        }
+        try {
+            const usage = extractCodexUsage(JSON.parse(raw));
+            if (usage) {
+                found = usage;
+            }
+        }
+        catch {
+            // Partial or non-JSON payload — the next chunk may complete it. Never
+            // let a malformed line escape into the relay.
+        }
+    }
+    return found;
+}
+/**
+ * Maximum bytes written by the opt-in raw capture. One `response.completed`
+ * event is a few hundred bytes; 256 KiB is generous and bounds a runaway file.
+ */
+const CAPTURE_LIMIT_BYTES = 256 * 1024;
+/**
+ * Opt-in raw capture of one Codex SSE stream, for confirming the `usage` wire
+ * shape against real traffic.
+ *
+ * Off unless `NEUROLINK_PROXY_CODEX_CAPTURE` names a file. It is deliberately
+ * env-gated and undocumented in the CLI: the captured bytes are the assistant's
+ * actual response, so this is a debugging tool the operator turns on
+ * deliberately, not something that runs by default. Capture stops at the first
+ * completed stream and is capped.
+ */
+function createCaptureSink() {
+    const target = process.env.NEUROLINK_PROXY_CODEX_CAPTURE;
+    if (!target) {
+        return null;
+    }
+    let written = 0;
+    let started = false;
+    return (chunk) => {
+        if (written >= CAPTURE_LIMIT_BYTES) {
+            return;
+        }
+        try {
+            // Append only the new bytes. Rewriting the accumulated buffer on every
+            // chunk is quadratic in stream length and runs in a live relay's
+            // transform(), so a long response would do hundreds of growing
+            // synchronous writes.
+            // Slice to the remaining capacity rather than writing the whole chunk.
+            // The guard above only says the cap was not ALREADY reached, so a single
+            // large chunk arriving at 255 KiB would otherwise land in full and the
+            // file would end up far past its bound — the cap has to hold per write,
+            // not per stream.
+            const remaining = CAPTURE_LIMIT_BYTES - written;
+            const slice = chunk.byteLength > remaining ? chunk.subarray(0, remaining) : chunk;
+            appendFileSync(target, slice, { flag: started ? "a" : "w" });
+            started = true;
+            written += slice.byteLength;
+        }
+        catch {
+            // Capture is best-effort telemetry; never let it touch the relay.
+        }
+    };
+}
+/**
+ * A pass-through TransformStream that reports the usage seen on a Codex SSE
+ * stream.
+ *
+ * `usage` resolves when the stream ends: to the last usage observed, or null if
+ * none was. It never rejects.
+ */
+export function createCodexUsageTap() {
+    let settleUsage = () => { };
+    const usage = new Promise((resolve) => {
+        settleUsage = resolve;
+    });
+    // flush() and cancel() are mutually exclusive in principle, but a
+    // double-settle must be harmless rather than relied upon.
+    let settled = false;
+    const settle = (value) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        settleUsage(value);
+    };
+    const decoder = new TextDecoder();
+    const capture = createCaptureSink();
+    let carry = "";
+    let latest = null;
+    /**
+     * Ceiling on the unterminated tail we are willing to hold.
+     *
+     * `carry` normally holds a fraction of one SSE line, because every newline
+     * flushes it. A stream that never sends one — a hung upstream, a
+     * non-SSE body relayed by mistake — would otherwise grow it without bound
+     * for the life of the request. One `response.completed` event is a few
+     * hundred bytes, so a megabyte is far past any real event, and dropping the
+     * tail costs at most the usage reading this tap is allowed to miss anyway.
+     */
+    const CARRY_LIMIT_CHARS = 1024 * 1024;
+    const transformer = {
+        transform(chunk, controller) {
+            // Bytes go out first and unconditionally: nothing below can delay or
+            // alter what the client receives.
+            controller.enqueue(chunk);
+            try {
+                capture?.(chunk);
+                carry += decoder.decode(chunk, { stream: true });
+                // Keep only the trailing partial line; events are newline-delimited.
+                const lastBreak = carry.lastIndexOf("\n");
+                if (lastBreak === -1) {
+                    if (carry.length > CARRY_LIMIT_CHARS) {
+                        // No line break in a megabyte: this is not the SSE stream we can
+                        // read. Give up on the tail rather than grow forever.
+                        carry = "";
+                    }
+                    return;
+                }
+                const complete = carry.slice(0, lastBreak);
+                carry = carry.slice(lastBreak + 1);
+                const seen = scanCodexSSEForUsage(complete);
+                if (seen) {
+                    latest = seen;
+                }
+            }
+            catch {
+                // Telemetry must never break the relay.
+            }
+        },
+        flush() {
+            try {
+                const seen = scanCodexSSEForUsage(carry);
+                if (seen) {
+                    latest = seen;
+                }
+            }
+            catch {
+                // ignored — see above
+            }
+            settle(latest);
+        },
+        /**
+         * A client hanging up mid-response, or an upstream error, aborts the
+         * stream rather than closing it — so flush() never runs. Without this the
+         * usage promise would never settle and every aborted request would leak a
+         * pending handler. Report whatever was seen before the abort.
+         */
+        cancel() {
+            settle(latest);
+        },
+    };
+    const stream = new TransformStream(transformer);
+    return { stream, usage };
+}
+//# sourceMappingURL=codexUsage.js.map

package/dist/lib/proxy/proxyAnalysis.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES, } from "./routingEvidence.js";
+import { calculateCost, hasPricing, isExactPricingMatch, } from "../utils/pricing.js";
 const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
@@ -358,6 +359,13 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
     let cacheReadTokens = 0;
     let cacheCreationTokens = 0;
     let inputTokens = 0;
+    let outputTokens = 0;
+    let estimatedCostUsd = 0;
+    let requestsPriced = 0;
+    let requestsPricedByPrefix = 0;
+    let requestsUnpriced = 0;
+    const modelsPricedByPrefix = new Set();
+    const unpricedModels = new Set();
     const finalRequestLatency = [];
     const singleAttemptDelta = [];
     const errorTypes = {};
@@ -394,13 +402,50 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
             singleAttemptDelta.push(request.durationMs - requestAttempts.totalDurationMs);
         }
         if (request.inputTokens !== null ||
+            request.outputTokens !== null ||
             request.cacheReadTokens !== null ||
             request.cacheCreationTokens !== null) {
             requestsWithUsage += 1;
             inputTokens += request.inputTokens ?? 0;
+            outputTokens += request.outputTokens ?? 0;
             cacheReadTokens += request.cacheReadTokens ?? 0;
             cacheCreationTokens += request.cacheCreationTokens ?? 0;
             requestsWithCacheRead += (request.cacheReadTokens ?? 0) > 0 ? 1 : 0;
+            if (request.model) {
+                // Records written before `provider` existed carry only a model name.
+                // "openai-compatible" resolves to the cross-provider table search in
+                // pricing.ts, which finds the model wherever it lives — a far better
+                // guess than assuming Anthropic and pricing a GPT model at $0.
+                const cost = calculateCost(request.provider ?? "openai-compatible", request.model, {
+                    input: request.inputTokens ?? 0,
+                    output: request.outputTokens ?? 0,
+                    total: (request.inputTokens ?? 0) +
+                        (request.outputTokens ?? 0) +
+                        (request.cacheCreationTokens ?? 0) +
+                        (request.cacheReadTokens ?? 0),
+                    cacheCreationTokens: request.cacheCreationTokens ?? 0,
+                    cacheReadTokens: request.cacheReadTokens ?? 0,
+                });
+                // Ask the table directly rather than inferring from cost > 0: a real
+                // request with trivial usage can round to $0.000000 and is priced, not
+                // unpriced.
+                const priced = hasPricing(request.provider ?? "openai-compatible", request.model);
+                if (priced) {
+                    estimatedCostUsd += cost;
+                    requestsPriced += 1;
+                    // A prefix fallback means the rate was inherited from a
+                    // similarly-named model, not quoted for this one. Surface it rather
+                    // than presenting a guess as a figure.
+                    if (!isExactPricingMatch(request.provider ?? "openai-compatible", request.model)) {
+                        requestsPricedByPrefix += 1;
+                        modelsPricedByPrefix.add(request.model);
+                    }
+                }
+                else {
+                    requestsUnpriced += 1;
+                    unpricedModels.add(request.model);
+                }
+            }
         }
     }
     return {
@@ -419,6 +464,13 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
             cacheReadTokens,
             cacheCreationTokens,
             inputTokens,
+            outputTokens,
+            estimatedCostUsd: Number(estimatedCostUsd.toFixed(6)),
+            requestsPriced,
+            requestsPricedByPrefix,
+            modelsPricedByPrefix: [...modelsPricedByPrefix].sort(),
+            requestsUnpriced,
+            unpricedModels: [...unpricedModels].sort(),
             requestHitRate: requestsWithUsage > 0
                 ? Number((requestsWithCacheRead / requestsWithUsage).toFixed(4))
                 : null,
@@ -695,13 +747,26 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("requests", record);
-            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
+            if (timestamp === null) {
                 return;
             }
             const requestId = stringValue(record.requestId);
             if (!requestId) {
                 return;
             }
+            // A streamed request is logged twice — once when the response headers
+            // are known, again when the body finishes and its token counts arrive
+            // — and those two writes can straddle the window edge. A Codex turn
+            // whose headers land at 23:59:50 and whose stream ends at 00:00:05 has
+            // every token it spent in the second record. Filtering that record out
+            // by its own timestamp would leave the request counted as completed
+            // but contributing nothing to tokens or cost, with nothing in the
+            // report to say so. A request the window already admitted therefore
+            // keeps accepting its own later records.
+            const alreadyAdmitted = finalRequests.has(requestId) || terminalStreamErrors.has(requestId);
+            if (!alreadyAdmitted && (timestamp < sinceMs || timestamp > untilMs)) {
+                return;
+            }
             if (finiteNumber(record.terminalStatus) !== null) {
                 terminalStreamErrors.add(requestId);
                 return;
@@ -723,19 +788,38 @@ export async function analyzeProxyLogs(options) {
             else {
                 absentRoutingDecisions += 1;
             }
-            finalRequests.set(requestId, {
+            const parsed = {
                 timestamp: new Date(timestamp).toISOString(),
                 status,
                 durationMs: finiteNumber(record.responseTimeMs),
                 account: stringValue(record.account) ?? "unknown",
                 accountType: stringValue(record.accountType) ?? "unknown",
+                model: stringValue(record.model),
+                provider: stringValue(record.provider),
                 inputTokens: finiteNumber(record.inputTokens),
+                outputTokens: finiteNumber(record.outputTokens),
                 cacheReadTokens: finiteNumber(record.cacheReadTokens),
                 cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
                 errorType: stringValue(record.errorType),
                 errorCode: stringValue(record.errorCode),
                 routingDecision,
-            });
+            };
+            // A request may be logged twice: once when the response headers are
+            // known, and again when a streamed body finishes and its token counts
+            // become available (the Codex engine does this). Merge rather than
+            // replace, so the later usage-bearing record cannot drop an errorType
+            // the first one carried, and vice versa.
+            const previous = finalRequests.get(requestId);
+            finalRequests.set(requestId, previous
+                ? {
+                    ...previous,
+                    ...Object.fromEntries(Object.entries(parsed).filter(([, value]) => value !== null && value !== undefined)),
+                    // Attribute the request to when it was first seen. A late
+                    // completion record must not move it out of the window that
+                    // admitted it.
+                    timestamp: previous.timestamp,
+                }
+                : parsed);
         }, () => {
             malformedLines += 1;
         });

package/dist/lib/proxy/proxyFetch.d.ts

@@ -47,3 +47,4 @@ export declare function getProxyStatus(): {
     method: string;
     capabilities: string[];
 };
+export declare function warnGoogleSdkIgnoresProxy(providerLabel: string): void;

package/dist/lib/proxy/proxyFetch.js

@@ -697,4 +697,33 @@ export function getProxyStatus() {
         ],
     };
 }
+/**
+ * One-time warning that the @google/genai SDK cannot honour a configured
+ * proxy.
+ *
+ * Both Google providers passed `httpOptions: { fetch: createProxyFetch() }`,
+ * which does nothing. `HttpOptions` in @google/genai 1.46.0 declares only
+ * baseUrl, baseUrlResourceScope, apiVersion, headers, timeout, extraBody and
+ * retryOptions — there is no `fetch` on it. That property belongs to a
+ * different interface (`ClientOptions`), which `GoogleGenAIOptions` does not
+ * accept, and the SDK's request path calls global `fetch`. The option was
+ * silently dropped and requests went direct.
+ *
+ * It type-checked only because those constructors are reached through a
+ * loosely-typed local alias, which turns off excess-property checking.
+ *
+ * This SDK version offers no supported injection point, so rather than keep a
+ * line that reads like working proxy support, the situation is reported once
+ * per process — and only to someone who actually configured a proxy. Silent
+ * bypass is the worst outcome available: a corporate user believes their
+ * traffic is proxied when it is not.
+ */
+let proxyUnsupportedWarned = false;
+export function warnGoogleSdkIgnoresProxy(providerLabel) {
+    if (proxyUnsupportedWarned || !getProxyStatus().enabled) {
+        return;
+    }
+    proxyUnsupportedWarned = true;
+    logger.warn(`[${providerLabel}] A proxy is configured, but the @google/genai SDK provides no way to route its requests through it (HttpOptions has no 'fetch', and GoogleGenAIOptions accepts none). Requests from this provider go direct.`);
+}
 //# sourceMappingURL=proxyFetch.js.map