@juspay/neurolink 11.18.4 → 11.19.0

package/dist/index.d.ts

@@ -445,3 +445,4 @@ export { TripwireEvaluator, createDefaultTripwireEvaluator, commonTripwires, } f
 export { Agent } from "./agent/agent.js";
 export { AgentNetwork } from "./agent/agentNetwork.js";
 export { AgentCoordinator, TaskDistributor, MessageBus, NetworkOrchestrator, NetworkTopology, TopologyBuilder, } from "./agent/index.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, readAllLocalUsage, registerLocalUsageReader, } from "./localUsage/index.js";

package/dist/index.js

@@ -745,3 +745,10 @@ AgentCoordinator, TaskDistributor,
 MessageBus, 
 // Orchestration
 NetworkOrchestrator, NetworkTopology, TopologyBuilder, } from "./agent/index.js";
+// ============================================================================
+// Local usage exports
+// ============================================================================
+// Token spend read from each CLI's own session logs, rather than from proxy
+// traffic. Exported because the proxy's ledger only sees CLIs that route
+// through it; this covers the rest, and covers history predating the proxy.
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, readAllLocalUsage, registerLocalUsageReader, } from "./localUsage/index.js";

package/dist/localUsage/claudeCodeReader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reads token usage out of Claude Code's own session transcripts.
+ *
+ * Layout, confirmed on a real machine rather than from documentation:
+ * `~/.claude/projects/<sanitized-cwd>/<sessionId>.jsonl`, where the sanitized
+ * cwd is the absolute working-directory path with every `/` replaced by `-`.
+ *
+ * The load-bearing detail is that top-level session transcripts are a tiny
+ * minority of the files. On the machine this was written against, 17,439
+ * transcripts totalling 9.7 GB broke down as roughly 103 top-level sessions
+ * against 17,116 subagent-task transcripts nested under
+ * `<sessionId>/subagents/`. A reader that globbed only `<project>/*.jsonl`
+ * would miss essentially all of a subagent-heavy user's real spend, so this
+ * one recurses.
+ *
+ * The files are not homogeneous message streams. A single 14,747-line
+ * transcript carried eleven distinct `type` values — `assistant`, `user`,
+ * `attachment`, `pr-link`, `last-prompt`, `mode`, `permission-mode`,
+ * `queue-operation`, `system`, `file-history-delta`, `file-history-snapshot` —
+ * several of which have no `message` key at all. Every one of its 6,028
+ * `type: "assistant"` lines carried a `message.usage` object, so that filter is
+ * safe, but everything else must be skipped rather than treated as malformed.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createClaudeCodeReader(): Promise<LocalUsageReader>;

package/dist/localUsage/claudeCodeReader.js

@@ -0,0 +1,222 @@
+/**
+ * Reads token usage out of Claude Code's own session transcripts.
+ *
+ * Layout, confirmed on a real machine rather than from documentation:
+ * `~/.claude/projects/<sanitized-cwd>/<sessionId>.jsonl`, where the sanitized
+ * cwd is the absolute working-directory path with every `/` replaced by `-`.
+ *
+ * The load-bearing detail is that top-level session transcripts are a tiny
+ * minority of the files. On the machine this was written against, 17,439
+ * transcripts totalling 9.7 GB broke down as roughly 103 top-level sessions
+ * against 17,116 subagent-task transcripts nested under
+ * `<sessionId>/subagents/`. A reader that globbed only `<project>/*.jsonl`
+ * would miss essentially all of a subagent-heavy user's real spend, so this
+ * one recurses.
+ *
+ * The files are not homogeneous message streams. A single 14,747-line
+ * transcript carried eleven distinct `type` values — `assistant`, `user`,
+ * `attachment`, `pr-link`, `last-prompt`, `mode`, `permission-mode`,
+ * `queue-operation`, `system`, `file-history-delta`, `file-history-snapshot` —
+ * several of which have no `message` key at all. Every one of its 6,028
+ * `type: "assistant"` lines carried a `message.usage` object, so that filter is
+ * safe, but everything else must be skipped rather than treated as malformed.
+ */
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { calculateCost, hasPricing } from "../utils/pricing.js";
+const CLI_ID = "claude-code";
+const DEFAULT_SINCE_DAYS = 30;
+const PROVIDER = "anthropic";
+function projectsRoot() {
+    return join(homedir(), ".claude", "projects");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "modeled",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+/**
+ * Every `.jsonl` under the projects root, at any depth.
+ *
+ * Depth matters here — see the module header. `withFileTypes` avoids a stat
+ * per entry, and a directory that cannot be read is skipped rather than
+ * aborting the walk: one unreadable project must not cost the other eleven
+ * thousand files.
+ */
+async function collectTranscripts(dir, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectTranscripts(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 transcript into `totals`.
+ *
+ * Read line by line rather than into a string: these files reach tens of
+ * megabytes, and a full-history scan opens thousands of them.
+ *
+ * Dedup is by `message.id`, keeping the LARGEST output count seen for that id.
+ * A resumed session re-logs turns it has already written, and the re-logged
+ * copy can carry a higher output count than the first — taking the max rather
+ * than the first or last is what makes a resumed session total correct instead
+ * of either under- or double-counted. The map is per-file and discarded after,
+ * so it stays bounded no matter how many files a scan covers.
+ */
+async function foldTranscript(filePath, totals, unpriced) {
+    const seen = new Map();
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of rl) {
+            if (!line || line.charCodeAt(0) !== 123 /* '{' */) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                // A transcript being appended to while we read it ends in a partial
+                // line. That is normal, not corruption — skip it.
+                continue;
+            }
+            const record = parsed;
+            if (record.type !== "assistant" || !record.message?.usage) {
+                continue;
+            }
+            const usage = record.message.usage;
+            const id = record.message.id;
+            if (typeof id !== "string" || id.length === 0) {
+                continue;
+            }
+            const candidate = {
+                model: record.message.model ?? "unknown",
+                input: num(usage.input_tokens),
+                output: num(usage.output_tokens),
+                read: num(usage.cache_read_input_tokens),
+                create: num(usage.cache_creation_input_tokens),
+            };
+            const existing = seen.get(id);
+            if (!existing || candidate.output > existing.output) {
+                seen.set(id, candidate);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    for (const turn of seen.values()) {
+        totals.requests += 1;
+        totals.inputTokens += turn.input;
+        totals.outputTokens += turn.output;
+        totals.cacheReadTokens += turn.read;
+        totals.cacheCreationTokens += turn.create;
+        if (hasPricing(PROVIDER, turn.model)) {
+            totals.costUsd += calculateCost(PROVIDER, turn.model, {
+                input: turn.input,
+                output: turn.output,
+                total: turn.input + turn.output,
+                cacheReadTokens: turn.read,
+                cacheCreationTokens: turn.create,
+            });
+        }
+        else {
+            totals.unpricedRequests += 1;
+            unpriced.add(turn.model);
+        }
+    }
+}
+export async function createClaudeCodeReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Claude Code",
+            verified: true,
+            dedupStrategy: "message-id-keep-max",
+            costConfidence: "modeled",
+            requiresSqlite: false,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(projectsRoot());
+                return info.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const unpriced = new Set();
+            const files = [];
+            await collectTranscripts(projectsRoot(), 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;
+                        }
+                    }
+                    await foldTranscript(file, totals, unpriced);
+                    filesScanned += 1;
+                }
+                catch (error) {
+                    // One unreadable transcript is a reportable fact, not a reason to
+                    // lose the totals from every other file in the scan.
+                    errors.push({
+                        cliId: CLI_ID,
+                        filePath: file,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            totals.unpricedModels = [...unpriced].sort();
+            // Confidence stays "modeled" even when some turns went unpriced, and the
+            // distinction matters. "heuristic" means the number itself was estimated
+            // — Kiro's byte-count figure, say. Here every dollar in `costUsd` came
+            // from a real rate table; what is missing is turns, not accuracy. That
+            // incompleteness is already reported precisely by `unpricedRequests` and
+            // `unpricedModels` (on this machine: Claude Code's internal
+            // "<synthetic>" model), so downgrading the whole row would overstate the
+            // doubt and make a genuinely estimated total indistinguishable from this
+            // one.
+            totals.costUsd = Math.round(totals.costUsd * 1_000_000) / 1_000_000;
+            return { cliId: CLI_ID, totals, filesScanned, errors };
+        },
+    };
+}

package/dist/localUsage/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Local usage: token spend read from each CLI's own session logs.
+ *
+ * The proxy's ledger can only account for traffic that went through it, which
+ * caps coverage at the CLIs that expose a base-URL override. Every CLI writes
+ * a local transcript regardless, so reading those covers the rest — and covers
+ * history from before the proxy existed.
+ */
+import type { LocalUsageAggregateReport, LocalUsageScanOptions } from "../types/index.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, registerLocalUsageReader, } from "./localUsageReaderRegistry.js";
+/**
+ * Scan every registered reader whose CLI is actually present on this machine.
+ *
+ * "Not installed" and "failed" are reported separately and deliberately: a CLI
+ * the user never installed is not an error, and collapsing the two would make
+ * a broken reader indistinguishable from an absent one.
+ */
+export declare function readAllLocalUsage(options?: LocalUsageScanOptions): Promise<LocalUsageAggregateReport>;

package/dist/localUsage/index.js

@@ -0,0 +1,46 @@
+/**
+ * Local usage: token spend read from each CLI's own session logs.
+ *
+ * The proxy's ledger can only account for traffic that went through it, which
+ * caps coverage at the CLIs that expose a base-URL override. Every CLI writes
+ * a local transcript regardless, so reading those covers the rest — and covers
+ * history from before the proxy existed.
+ */
+import { createLocalUsageReader, getRegisteredLocalUsageCliIds, } from "./localUsageReaderRegistry.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, registerLocalUsageReader, } from "./localUsageReaderRegistry.js";
+/**
+ * Scan every registered reader whose CLI is actually present on this machine.
+ *
+ * "Not installed" and "failed" are reported separately and deliberately: a CLI
+ * the user never installed is not an error, and collapsing the two would make
+ * a broken reader indistinguishable from an absent one.
+ */
+export async function readAllLocalUsage(options) {
+    const totals = {};
+    const failures = [];
+    const notInstalled = [];
+    for (const cliId of getRegisteredLocalUsageCliIds()) {
+        try {
+            const reader = await createLocalUsageReader(cliId);
+            if (!(await reader.detect())) {
+                notInstalled.push(cliId);
+                continue;
+            }
+            const result = await reader.scan(options);
+            totals[cliId] = result.totals;
+        }
+        catch (error) {
+            // One reader throwing must not lose the others' results.
+            failures.push({
+                cliId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        totals,
+        failures,
+        notInstalled,
+    };
+}

package/dist/localUsage/localUsageReaderRegistry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Registry of local-usage readers, one per CLI.
+ *
+ * Mirrors `providerRegistry.ts`: descriptors are static and always available,
+ * while the reader itself arrives through a dynamic import inside its factory.
+ * Same reason as the provider registry — a static import graph across a dozen
+ * readers is how circular dependencies start, and it would also force every
+ * reader's cost of loading onto a caller who only wanted one of them.
+ */
+import type { LocalUsageCliId, LocalUsageReader, LocalUsageReaderDescriptor, LocalUsageReaderRegistration } from "../types/index.js";
+export declare function registerLocalUsageReader(registration: LocalUsageReaderRegistration): void;
+export declare function getLocalUsageDescriptors(): LocalUsageReaderDescriptor[];
+export declare function getRegisteredLocalUsageCliIds(): LocalUsageCliId[];
+export declare function createLocalUsageReader(cliId: LocalUsageCliId): Promise<LocalUsageReader>;

package/dist/localUsage/localUsageReaderRegistry.js

@@ -0,0 +1,40 @@
+/**
+ * Registry of local-usage readers, one per CLI.
+ *
+ * Mirrors `providerRegistry.ts`: descriptors are static and always available,
+ * while the reader itself arrives through a dynamic import inside its factory.
+ * Same reason as the provider registry — a static import graph across a dozen
+ * readers is how circular dependencies start, and it would also force every
+ * reader's cost of loading onto a caller who only wanted one of them.
+ */
+const registry = new Map();
+export function registerLocalUsageReader(registration) {
+    registry.set(registration.descriptor.id, registration);
+}
+export function getLocalUsageDescriptors() {
+    return [...registry.values()].map((entry) => entry.descriptor);
+}
+export function getRegisteredLocalUsageCliIds() {
+    return [...registry.keys()];
+}
+export async function createLocalUsageReader(cliId) {
+    const registration = registry.get(cliId);
+    if (!registration) {
+        throw new Error(`No local-usage reader registered for "${cliId}". Registered: ${getRegisteredLocalUsageCliIds().join(", ") || "(none)"}`);
+    }
+    return registration.factory();
+}
+registerLocalUsageReader({
+    descriptor: {
+        id: "claude-code",
+        displayName: "Claude Code",
+        verified: true,
+        dedupStrategy: "message-id-keep-max",
+        costConfidence: "modeled",
+        requiresSqlite: false,
+    },
+    factory: async () => {
+        const { createClaudeCodeReader } = await import("./claudeCodeReader.js");
+        return createClaudeCodeReader();
+    },
+});

package/dist/proxy/geminiFormat.js

@@ -20,6 +20,14 @@
  */
 /** Google's role for assistant turns. */
 const MODEL_ROLE = "model";
+/**
+ * Sent as `input.text` when a request's final turn is a model turn.
+ *
+ * Google lets a client continue generation from the assistant's own last turn;
+ * the chat-completions wire format the engine targets has no way to say that,
+ * and an empty prompt is rejected before any provider is reached.
+ */
+const CONTINUATION_PROMPT = "Continue.";
 function partsToText(parts) {
     if (!Array.isArray(parts)) {
         return "";
@@ -91,11 +99,24 @@ export function parseGeminiRequest(model, body, stream) {
     // it, which is the same lost-turn bug one case further along.
     //
     // A terminal placeholder restores the invariant: the slice removes this
-    // instead of the model turn. It is never sent anywhere — `prompt` is
-    // independently "" in exactly this case, so the placeholder only exists to be
-    // consumed by the slice.
+    // instead of the model turn.
+    //
+    // The prompt needs its own answer, and leaving it "" was a 500. A
+    // model-final request carries no user turn to send as `input.text`, and
+    // NeuroLink's stream() rejects an empty one outright — "Stream options must
+    // include either input.text, input.audio, or stt.audio" — so every continue
+    // from a model turn failed at the door rather than reaching a provider. The
+    // placeholder above fixed the history slice but never exercised this path,
+    // because nothing had sent the request.
+    //
+    // Google's semantics for a model-final `contents` are "keep going", and the
+    // chat-completions shape the engine translates into has no assistant-prefill
+    // to express that. An explicit continuation instruction is the closest
+    // faithful equivalent: the full conversation still arrives as history, and
+    // the model is told to continue it rather than being handed an empty turn.
     if (turns.length > 0 && turns[turns.length - 1].role !== "user") {
-        conversationMessages.push({ role: "user", content: "" });
+        conversationMessages.push({ role: "user", content: CONTINUATION_PROMPT });
+        prompt = CONTINUATION_PROMPT;
     }
     const numeric = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
     const stops = generationConfig.stopSequences;

package/dist/types/index.d.ts

@@ -84,3 +84,4 @@ export * from "./modelPool.js";
 export * from "./requestRouter.js";
 export * from "./classifierRouter.js";
 export * from "./agentNetwork.js";
+export * from "./localUsage.js";

package/dist/types/index.js

@@ -95,3 +95,4 @@ export * from "./requestRouter.js";
 export * from "./classifierRouter.js";
 // Multi-Agent orchestration types
 export * from "./agentNetwork.js";
+export * from "./localUsage.js";

package/dist/types/localUsage.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Types for `src/lib/localUsage/` — reading token usage out of each AI CLI's
+ * own local session logs.
+ *
+ * Why this exists alongside the proxy's ledger: the proxy can only account for
+ * traffic that went through it, which caps coverage at the CLIs that expose a
+ * base-URL override. Every CLI writes its own local transcript regardless, so
+ * reading those recovers the rest — and recovers history from before the proxy
+ * was ever installed. It is also an independent source of truth: a pricing
+ * defect in the proxy's own accounting cannot hide from a reader that derives
+ * cost from a different input.
+ */
+/**
+ * Stable identifier for one CLI this subsystem can read local usage from.
+ * Kebab-case, matching `CliProxyClientConfigurator.id`'s convention — a
+ * different registry, but the same repo-wide convention for CLI identifiers.
+ */
+export type LocalUsageCliId = "claude-code" | "codex" | "gemini-cli" | "opencode" | "qwen-code" | "copilot-cli" | "cursor" | "amp" | "hermes" | "kiro" | "antigravity" | "grok";
+/**
+ * How much to trust a computed cost figure.
+ *
+ * Not decoration: some CLIs are flat-rate subscriptions where a per-request
+ * cost is meaningless, and at least one publishes a byte heuristic rather than
+ * a real number. A caller must never render "heuristic" with the same
+ * confidence as "modeled", so the distinction travels with the number.
+ */
+export type LocalUsageCostConfidence = "modeled" | "unavailable" | "heuristic";
+/**
+ * How a reader avoids counting the same turn twice.
+ *
+ * Metadata on the descriptor, for introspection and for the person writing the
+ * next reader — the aggregator does not branch on it.
+ */
+export type LocalUsageDedupStrategy = "message-id-keep-max" | "last-write-wins" | "rowid-high-water-mark" | "session-dag";
+/** Aggregated totals for one CLI, one scan. */
+export type LocalUsageTotals = {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    costUsd: number;
+    /**
+     * The weakest confidence contributing to `costUsd`. A totals row mixing
+     * modeled and heuristic entries must report the weaker one, otherwise the
+     * aggregate looks better-sourced than its worst input.
+     */
+    costConfidence: LocalUsageCostConfidence;
+    /** Turns whose model had no pricing entry, so contributed 0 to costUsd. */
+    unpricedRequests: number;
+    /** Distinct model ids behind `unpricedRequests`, for diagnosis. */
+    unpricedModels: string[];
+};
+/** A non-fatal per-file problem, surfaced instead of aborting the scan. */
+export type LocalUsageScanError = {
+    cliId: LocalUsageCliId;
+    filePath: string;
+    message: string;
+};
+/** What one reader's `scan()` returns. */
+export type LocalUsageScanResult = {
+    cliId: LocalUsageCliId;
+    totals: LocalUsageTotals;
+    /** Files opened during this scan, after any time filter. */
+    filesScanned: number;
+    errors: LocalUsageScanError[];
+};
+/** Static metadata, available without constructing a reader. */
+export type LocalUsageReaderDescriptor = {
+    id: LocalUsageCliId;
+    displayName: string;
+    /**
+     * True only for readers checked against real data on a real machine. An
+     * honesty marker, not a completeness claim — an unverified reader may still
+     * be correct, it just has not been shown to be.
+     */
+    verified: boolean;
+    dedupStrategy: LocalUsageDedupStrategy;
+    costConfidence: LocalUsageCostConfidence;
+    /** Whether reading this CLI's store needs a SQLite binding. */
+    requiresSqlite: boolean;
+};
+/** Options accepted by every reader's `scan()` and by the aggregator. */
+export type LocalUsageScanOptions = {
+    /**
+     * Only read files modified within this many days. Defaults to 30.
+     *
+     * This is a real constraint rather than a convenience: one developer machine
+     * held 17,439 transcripts totalling 9.7 GB, and an unbounded scan reads all
+     * of it on every call. Pass `Infinity` for a deliberate full history sweep.
+     */
+    sinceDays?: number;
+};
+/** The contract every reader implements — one per CLI. */
+export type LocalUsageReader = {
+    descriptor: LocalUsageReaderDescriptor;
+    /**
+     * Whether this CLI's local store appears to exist on this machine at all —
+     * the same "do not report on something never installed" discipline the proxy
+     * client configurators use before writing a config.
+     */
+    detect: () => Promise<boolean>;
+    scan: (options?: LocalUsageScanOptions) => Promise<LocalUsageScanResult>;
+};
+/** Async factory stored in the registry — a reader needs no credentials, only
+ * the filesystem, so this takes no arguments. */
+export type LocalUsageReaderFactoryFn = () => Promise<LocalUsageReader>;
+/** One entry in the registry map. */
+export type LocalUsageReaderRegistration = {
+    descriptor: LocalUsageReaderDescriptor;
+    factory: LocalUsageReaderFactoryFn;
+};
+/** A whole reader failing — not installed, or threw — so the aggregate report
+ * can carry successes and failures side by side rather than losing both. */
+export type LocalUsageReaderFailure = {
+    cliId: LocalUsageCliId;
+    message: string;
+};
+/** Top-level output of scanning every registered, detected reader. */
+export type LocalUsageAggregateReport = {
+    generatedAt: string;
+    /** Only CLIs whose store was detected AND scanned appear here. */
+    totals: Partial<Record<LocalUsageCliId, LocalUsageTotals>>;
+    /** CLIs that were registered but produced nothing, and why. */
+    failures: LocalUsageReaderFailure[];
+    /** CLIs with no local store on this machine — absent, not failed. */
+    notInstalled: LocalUsageCliId[];
+};
+/**
+ * The `message.usage` object exactly as Claude Code writes it into a
+ * transcript line — snake_case, and every field optional because older
+ * transcripts predate some of them.
+ */
+export type LocalUsageClaudeRawUsage = {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+};

package/dist/types/localUsage.js

@@ -0,0 +1,13 @@
+/**
+ * Types for `src/lib/localUsage/` — reading token usage out of each AI CLI's
+ * own local session logs.
+ *
+ * Why this exists alongside the proxy's ledger: the proxy can only account for
+ * traffic that went through it, which caps coverage at the CLIs that expose a
+ * base-URL override. Every CLI writes its own local transcript regardless, so
+ * reading those recovers the rest — and recovers history from before the proxy
+ * was ever installed. It is also an independent source of truth: a pricing
+ * defect in the proxy's own accounting cannot hide from a reader that derives
+ * cost from a different input.
+ */
+export {};