@juspay/neurolink 11.19.0 → 11.20.1

package/dist/localUsage/codexReader.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reads token usage out of Codex's own rollout transcripts.
+ *
+ * Layout: `~/.codex/sessions/<yyyy>/<mm>/<dd>/rollout-<iso>-<sessionId>.jsonl`.
+ * Each line is one of `session_meta`, `turn_context`, `response_item` or
+ * `event_msg`; usage lives on `event_msg` records whose `payload.type` is
+ * `token_count`.
+ *
+ * The counter semantics are the whole story here, and they are the opposite of
+ * the Claude Code reader's. Every `token_count` event carries BOTH a
+ * cumulative `total_token_usage` for the session and a per-turn
+ * `last_token_usage`. Summing the per-turn values is the obvious move and it is
+ * wrong: measured across all 108 sessions on a real machine, summing yields
+ * 9,191,613,238 tokens against a true 5,653,217,442 — an overstatement of
+ * 62.6%, and 195% on the worst single session. The per-turn value repeats
+ * across events within a turn, so it double-counts.
+ *
+ * The cumulative counter is authoritative and was monotonic in all 108
+ * sessions — it never resets mid-file — so the last one in the file is the
+ * session's true total. `Math.max` is still used rather than "last seen",
+ * because a counter that is only monotonic in every case observed is not the
+ * same as one that is guaranteed to be, and the max costs nothing.
+ *
+ * Cost is deliberately not computed. Codex is a ChatGPT subscription — the
+ * rollouts carry `rate_limits.plan_type` — so a per-token dollar figure would
+ * be an invention, not a measurement. The tokens are real; the cost is
+ * `unavailable`.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createCodexReader(): Promise<LocalUsageReader>;

package/dist/localUsage/codexReader.js

@@ -0,0 +1,218 @@
+/**
+ * Reads token usage out of Codex's own rollout transcripts.
+ *
+ * Layout: `~/.codex/sessions/<yyyy>/<mm>/<dd>/rollout-<iso>-<sessionId>.jsonl`.
+ * Each line is one of `session_meta`, `turn_context`, `response_item` or
+ * `event_msg`; usage lives on `event_msg` records whose `payload.type` is
+ * `token_count`.
+ *
+ * The counter semantics are the whole story here, and they are the opposite of
+ * the Claude Code reader's. Every `token_count` event carries BOTH a
+ * cumulative `total_token_usage` for the session and a per-turn
+ * `last_token_usage`. Summing the per-turn values is the obvious move and it is
+ * wrong: measured across all 108 sessions on a real machine, summing yields
+ * 9,191,613,238 tokens against a true 5,653,217,442 — an overstatement of
+ * 62.6%, and 195% on the worst single session. The per-turn value repeats
+ * across events within a turn, so it double-counts.
+ *
+ * The cumulative counter is authoritative and was monotonic in all 108
+ * sessions — it never resets mid-file — so the last one in the file is the
+ * session's true total. `Math.max` is still used rather than "last seen",
+ * because a counter that is only monotonic in every case observed is not the
+ * same as one that is guaranteed to be, and the max costs nothing.
+ *
+ * Cost is deliberately not computed. Codex is a ChatGPT subscription — the
+ * rollouts carry `rate_limits.plan_type` — so a per-token dollar figure would
+ * be an invention, not a measurement. The tokens are real; the cost is
+ * `unavailable`.
+ */
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+const CLI_ID = "codex";
+const DEFAULT_SINCE_DAYS = 30;
+function sessionsRoot() {
+    return join(homedir(), ".codex", "sessions");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "unavailable",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+async function collectRollouts(dir, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        // One unreadable date directory must not cost the rest of the scan.
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectRollouts(full, out);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * Fold one rollout into a single session-level rollup.
+ *
+ * `billableEvents` counts only the `token_count` events where the cumulative
+ * total actually advanced. Counting every event instead would inherit exactly
+ * the repetition that makes summing the per-turn values wrong.
+ */
+async function readRollout(filePath) {
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    let model;
+    let bestTotal = -1;
+    let best;
+    let previousTotal = -1;
+    let billableEvents = 0;
+    try {
+        for await (const line of rl) {
+            // Cheap reject before JSON.parse: these files reach hundreds of MB and
+            // most lines are conversation content with no usage on them at all.
+            const isTokenCount = line.includes('"token_count"');
+            const isTurnContext = line.includes('"turn_context"');
+            if (!isTokenCount && !isTurnContext) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                // A rollout being appended to while we read it ends mid-line.
+                continue;
+            }
+            const record = parsed;
+            if (record.type === "turn_context" && record.payload?.model) {
+                // Last one wins: a session can switch models partway through, and the
+                // most recent is the better single label for it.
+                model = record.payload.model;
+                continue;
+            }
+            if (record.payload?.type !== "token_count") {
+                continue;
+            }
+            const cumulative = record.payload.info?.total_token_usage;
+            if (!cumulative) {
+                continue;
+            }
+            const total = num(cumulative.total_tokens);
+            if (total > previousTotal) {
+                billableEvents += 1;
+            }
+            previousTotal = total;
+            if (total > bestTotal) {
+                bestTotal = total;
+                best = {
+                    input: num(cumulative.input_tokens),
+                    output: num(cumulative.output_tokens),
+                    cached: num(cumulative.cached_input_tokens),
+                };
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    if (!best) {
+        return null;
+    }
+    return { model, billableEvents, ...best };
+}
+export async function createCodexReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Codex",
+            verified: true,
+            dedupStrategy: "session-dag",
+            costConfidence: "unavailable",
+            requiresSqlite: false,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(sessionsRoot());
+                return info.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const models = new Set();
+            const files = [];
+            await collectRollouts(sessionsRoot(), files);
+            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const cutoff = Number.isFinite(sinceDays) && sinceDays > 0
+                ? Date.now() - sinceDays * 86_400_000
+                : undefined;
+            let filesScanned = 0;
+            for (const file of files) {
+                try {
+                    if (cutoff !== undefined) {
+                        const info = await stat(file);
+                        if (info.mtimeMs < cutoff) {
+                            continue;
+                        }
+                    }
+                    const rollup = await readRollout(file);
+                    filesScanned += 1;
+                    if (!rollup) {
+                        continue;
+                    }
+                    totals.requests += rollup.billableEvents;
+                    // `cached_input_tokens` is a SUBSET of `input_tokens` here — verified
+                    // on all 108 sessions, where input + output == total exactly and
+                    // cached <= input always. The other readers keep the two disjoint, so
+                    // the cached portion is subtracted out rather than reported twice; a
+                    // caller adding inputTokens + cacheReadTokens would otherwise
+                    // over-count Codex and not the rest.
+                    totals.inputTokens += Math.max(0, rollup.input - rollup.cached);
+                    totals.cacheReadTokens += rollup.cached;
+                    totals.outputTokens += rollup.output;
+                    if (rollup.model) {
+                        models.add(rollup.model);
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        cliId: CLI_ID,
+                        filePath: file,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            // Every turn is unpriced by construction, not by accident: see the note
+            // on this module about Codex being a subscription. Naming the models
+            // keeps that legible instead of looking like a lookup that failed.
+            totals.unpricedRequests = totals.requests;
+            totals.unpricedModels = [...models].sort();
+            return { cliId: CLI_ID, totals, filesScanned, errors };
+        },
+    };
+}

package/dist/localUsage/localUsageReaderRegistry.js

@@ -38,3 +38,17 @@ registerLocalUsageReader({
         return createClaudeCodeReader();
     },
 });
+registerLocalUsageReader({
+    descriptor: {
+        id: "codex",
+        displayName: "Codex",
+        verified: true,
+        dedupStrategy: "session-dag",
+        costConfidence: "unavailable",
+        requiresSqlite: false,
+    },
+    factory: async () => {
+        const { createCodexReader } = await import("./codexReader.js");
+        return createCodexReader();
+    },
+});

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -187,6 +187,20 @@ declare function executeClaudeFallbackTranslation(args: {
     }) => void;
     options: Parameters<ServerContext["neurolink"]["stream"]>[0];
     providerLabel: string;
+    /**
+     * Idle timeout for the fallback stream, in ms. Defaults to
+     * FALLBACK_STREAM_IDLE_TIMEOUT_MS.
+     *
+     * Injectable purely so a test can drive the timeout path in milliseconds
+     * instead of two minutes. The alternative the coverage used before was
+     * patching `globalThis.setTimeout` to fire every timer at 0ms for the
+     * duration of an await — which rewrites the delay of ANY timer created in
+     * that window, not just this one's, inside a 280-case suite sharing a single
+     * process. That is not a hypothetical: an attempt to measure the patched
+     * case with its own `setTimeout`-based watchdog had the watchdog rewritten
+     * out from under it and reported an instant false hang.
+     */
+    idleTimeoutMs?: number;
 }): Promise<unknown>;
 declare function executeClaudeFallbackWithRetry(args: Parameters<typeof executeClaudeFallbackTranslation>[0]): Promise<unknown>;
 declare function buildClaudeAnthropicFailureResponse(args: {

package/dist/server/routes/claudeProxyRoutes.js

@@ -2690,14 +2690,14 @@ async function loadClaudeProxyAccounts(args) {
     };
 }
 async function executeClaudeFallbackTranslation(args) {
-    const { ctx, body, tracer, requestStartTime, logProxyBody, logFinalRequest, options, providerLabel, } = args;
+    const { ctx, body, tracer, requestStartTime, logProxyBody, logFinalRequest, options, providerLabel, idleTimeoutMs = FALLBACK_STREAM_IDLE_TIMEOUT_MS, } = args;
     const fallbackAbortController = new AbortController();
     let streamResult;
     try {
         streamResult = await withTimeout(ctx.neurolink.stream({
             ...options,
             abortSignal: fallbackAbortController.signal,
-        }), FALLBACK_STREAM_IDLE_TIMEOUT_MS, `Fallback ${providerLabel} initialization timed out after ${FALLBACK_STREAM_IDLE_TIMEOUT_MS}ms`);
+        }), idleTimeoutMs, `Fallback ${providerLabel} initialization timed out after ${idleTimeoutMs}ms`);
     }
     catch (error) {
         fallbackAbortController.abort(error);
@@ -2708,7 +2708,7 @@ async function executeClaudeFallbackTranslation(args) {
         let collectedText = "";
         try {
             while (true) {
-                const { value: chunk, done } = await withTimeout(iterator.next(), FALLBACK_STREAM_IDLE_TIMEOUT_MS, `Fallback ${providerLabel} stream timed out after ${FALLBACK_STREAM_IDLE_TIMEOUT_MS}ms of inactivity`);
+                const { value: chunk, done } = await withTimeout(iterator.next(), idleTimeoutMs, `Fallback ${providerLabel} stream timed out after ${idleTimeoutMs}ms of inactivity`);
                 if (done) {
                     return collectedText;
                 }

package/dist/types/localUsage.d.ts

@@ -137,3 +137,17 @@ export type LocalUsageClaudeRawUsage = {
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
 };
+/**
+ * One Codex rollout reduced to its session-level totals.
+ *
+ * The token figures here are the session's CUMULATIVE counter, not a sum of
+ * per-turn values — see `codexReader.ts` for why summing overstates by ~63%.
+ */
+export type LocalUsageCodexSessionRollup = {
+    model?: string;
+    input: number;
+    output: number;
+    cached: number;
+    /** token_count events where the cumulative total actually advanced. */
+    billableEvents: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.19.0",
+  "version": "11.20.1",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {