@juspay/neurolink 11.18.5 → 11.20.0

package/dist/types/localUsage.d.ts

@@ -0,0 +1,153 @@
+/**
+ * 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;
+};
+/**
+ * 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/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 {};

package/dist/utils/messageBuilder.js

@@ -487,82 +487,6 @@ export async function buildMessagesArray(options) {
     else if ("input" in options && options.input?.text) {
         currentPrompt = options.input.text;
     }
-    // Process CSV files if present and inject into prompt using proper CSV parser
-    if ("input" in options && options.input) {
-        const input = options.input;
-        let csvContent = "";
-        const csvOptions = "csvOptions" in options ? options.csvOptions : undefined;
-        // Process explicit csvFiles array
-        if (input.csvFiles && input.csvFiles.length > 0) {
-            for (let i = 0; i < input.csvFiles.length; i++) {
-                const csvFile = input.csvFiles[i];
-                const filename = extractFilename(csvFile, i);
-                const filePath = typeof csvFile === "string" ? csvFile : filename;
-                try {
-                    const result = await FileDetector.detectAndProcess(csvFile, {
-                        allowedTypes: ["csv"],
-                        csvOptions: csvOptions,
-                    });
-                    let csvSection = `\n\n## CSV Data from "${filename}":\n`;
-                    // Add metadata from csv-parser library
-                    if (result.metadata) {
-                        const metadataText = formatCSVMetadata(result.metadata);
-                        if (metadataText) {
-                            csvSection += metadataText + `\n\n`;
-                        }
-                    }
-                    // Put the actual CSV content BEFORE the tool instructions —
-                    // buildCSVToolInstructions references "the CSV data shown above"
-                    // and the trailing position keeps that reference accurate.
-                    // Vertex Gemini misreads CSV-only prompts as "no files attached"
-                    // when the NOTE-then-data order makes the reference dangle.
-                    csvSection += result.content;
-                    csvSection += buildCSVToolInstructions(filePath);
-                    csvContent += csvSection;
-                    logger.info(`[CSV] ✅ Processed: ${filename}`, result.metadata);
-                }
-                catch (error) {
-                    logger.error(`[CSV] ❌ Failed to process ${filename}:`, error);
-                    csvContent += `\n\n## CSV Data Error: Failed to process "${filename}"\nReason: ${error instanceof Error ? error.message : "Unknown error"}`;
-                }
-            }
-        }
-        // Process unified files array (auto-detect CSV)
-        if (input.files && input.files.length > 0) {
-            for (const file of input.files) {
-                const filename = extractFilename(file);
-                try {
-                    const result = await FileDetector.detectAndProcess(file, {
-                        maxSize: 50 * 1024 * 1024,
-                        allowedTypes: ["csv"],
-                        csvOptions: csvOptions,
-                        mimetypeHint: isFileWithMetadata(file) ? file.mimetype : undefined,
-                    });
-                    if (result.type === "csv") {
-                        let csvSection = `\n\n## CSV Data from "${filename}":\n`;
-                        // Add metadata from csv-parser library
-                        if (result.metadata) {
-                            const metadataText = formatCSVMetadata(result.metadata);
-                            if (metadataText) {
-                                csvSection += metadataText + `\n\n`;
-                            }
-                        }
-                        csvSection += result.content;
-                        csvContent += csvSection;
-                        logger.info(`[FileDetector] ✅ CSV: ${filename}`, result.metadata);
-                    }
-                }
-                catch (error) {
-                    // Silently skip non-CSV files in auto-detect mode
-                    logger.debug(`[FileDetector] Skipped ${filename}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        // Prepend CSV content to current prompt
-        if (csvContent) {
-            currentPrompt = csvContent + (currentPrompt || "");
-        }
-    }
     if (currentPrompt?.trim()) {
         messages.push({
             role: "user",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.18.5",
+  "version": "11.20.0",
   "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": {
@@ -123,6 +123,7 @@
     "test:music:unit": "npx tsx test/continuous-test-suite-music-unit.ts",
     "test:image-gen": "npx tsx test/continuous-test-suite-image-gen-extras.ts",
     "test:credentials": "npx tsx test/continuous-test-suite-credentials.ts",
+    "test:local-usage": "npx tsx test/continuous-test-suite-local-usage.ts",
     "test:dynamic": "npx tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "npx tsx test/continuous-test-suite-proxy.ts",
     "test:codex": "npx tsx test/continuous-test-suite-codex.ts",