@juspay/neurolink 11.20.0 → 11.21.0

package/dist/localUsage/localUsageReaderRegistry.js

@@ -52,3 +52,17 @@ registerLocalUsageReader({
         return createCodexReader();
     },
 });
+registerLocalUsageReader({
+    descriptor: {
+        id: "opencode",
+        displayName: "OpenCode",
+        verified: true,
+        dedupStrategy: "rowid-high-water-mark",
+        costConfidence: "unavailable",
+        requiresSqlite: true,
+    },
+    factory: async () => {
+        const { createOpenCodeReader } = await import("./openCodeReader.js");
+        return createOpenCodeReader();
+    },
+});

package/dist/localUsage/openCodeReader.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Reads token usage out of OpenCode's local SQLite store.
+ *
+ * Store: `~/.local/share/opencode/opencode.db` (NOT `~/.config/opencode`,
+ * which holds only configuration). Usage lives on the `message` table, whose
+ * `data` column is a JSON blob carrying `role`, `modelID`, `providerID`,
+ * `cost` and a `tokens` object.
+ *
+ * Two things the real data settled, both of which would corrupt totals
+ * silently if assumed instead of checked.
+ *
+ * **Cache is DISJOINT from input here.** Measured across all 4,674
+ * usage-bearing messages on a reference machine, `total` equals
+ * `input + output + cache.read + cache.write` — never `input + output` alone
+ * unless cache happened to be zero. This is the opposite of Codex, where
+ * `cached_input_tokens` is a SUBSET of `input_tokens` and has to be subtracted
+ * back out. Three readers now, three conventions; none of them is safe to
+ * infer from the others.
+ *
+ * **OpenCode's own `cost` field is not usable.** It was 0 in all 4,674
+ * messages, while the provider mix spanned `github-copilot` (a subscription),
+ * `openai` (metered) and `neurolink` (this proxy). A single cost figure for
+ * that mixture would be wrong whichever way it was computed, so tokens are
+ * reported and cost is declared `unavailable` rather than invented or
+ * quietly zeroed.
+ *
+ * Worth knowing for anyone summing sources: traffic OpenCode sent through the
+ * NeuroLink proxy appears under `providerID: "neurolink"` here AND in the
+ * proxy's own ledger. The two are independent measurements of the same
+ * requests, not additive. On the reference machine that was 41 messages and
+ * ~772k tokens against 458M total, so it is small — but it is not zero, and a
+ * dashboard adding local usage to proxy usage double-counts exactly that
+ * slice.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createOpenCodeReader(): Promise<LocalUsageReader>;

package/dist/localUsage/openCodeReader.js

@@ -0,0 +1,196 @@
+/**
+ * Reads token usage out of OpenCode's local SQLite store.
+ *
+ * Store: `~/.local/share/opencode/opencode.db` (NOT `~/.config/opencode`,
+ * which holds only configuration). Usage lives on the `message` table, whose
+ * `data` column is a JSON blob carrying `role`, `modelID`, `providerID`,
+ * `cost` and a `tokens` object.
+ *
+ * Two things the real data settled, both of which would corrupt totals
+ * silently if assumed instead of checked.
+ *
+ * **Cache is DISJOINT from input here.** Measured across all 4,674
+ * usage-bearing messages on a reference machine, `total` equals
+ * `input + output + cache.read + cache.write` — never `input + output` alone
+ * unless cache happened to be zero. This is the opposite of Codex, where
+ * `cached_input_tokens` is a SUBSET of `input_tokens` and has to be subtracted
+ * back out. Three readers now, three conventions; none of them is safe to
+ * infer from the others.
+ *
+ * **OpenCode's own `cost` field is not usable.** It was 0 in all 4,674
+ * messages, while the provider mix spanned `github-copilot` (a subscription),
+ * `openai` (metered) and `neurolink` (this proxy). A single cost figure for
+ * that mixture would be wrong whichever way it was computed, so tokens are
+ * reported and cost is declared `unavailable` rather than invented or
+ * quietly zeroed.
+ *
+ * Worth knowing for anyone summing sources: traffic OpenCode sent through the
+ * NeuroLink proxy appears under `providerID: "neurolink"` here AND in the
+ * proxy's own ledger. The two are independent measurements of the same
+ * requests, not additive. On the reference machine that was 41 messages and
+ * ~772k tokens against 458M total, so it is small — but it is not zero, and a
+ * dashboard adding local usage to proxy usage double-counts exactly that
+ * slice.
+ */
+import { stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+const CLI_ID = "opencode";
+const DEFAULT_SINCE_DAYS = 30;
+function databasePath() {
+    return join(homedir(), ".local", "share", "opencode", "opencode.db");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "unavailable",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export async function createOpenCodeReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "OpenCode",
+            verified: true,
+            dedupStrategy: "rowid-high-water-mark",
+            costConfidence: "unavailable",
+            requiresSqlite: true,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(databasePath());
+                return info.isFile();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const models = new Set();
+            const dbPath = databasePath();
+            // `node:sqlite` is built in from Node 22 but still flagged experimental,
+            // so it can be absent or change shape. Imported lazily and behind a
+            // try/catch: a runtime without it must degrade to a reported failure for
+            // this one reader, not take down a scan of all the others.
+            let DatabaseSync;
+            try {
+                const sqlite = await import("node:sqlite");
+                // Validated, not asserted. The module is experimental and may change
+                // shape between Node releases; a cast would let a changed export sail
+                // through and fail later as an unrelated TypeError deep in the scan.
+                if (typeof sqlite === "object" &&
+                    sqlite !== null &&
+                    "DatabaseSync" in sqlite &&
+                    typeof sqlite.DatabaseSync ===
+                        "function") {
+                    DatabaseSync = sqlite.DatabaseSync;
+                }
+            }
+            catch (error) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                });
+                return { cliId: CLI_ID, totals, filesScanned: 0, errors };
+            }
+            if (!DatabaseSync) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: "node:sqlite did not expose a callable DatabaseSync — the experimental API has likely changed shape",
+                });
+                return { cliId: CLI_ID, totals, filesScanned: 0, errors };
+            }
+            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const cutoffMs = Number.isFinite(sinceDays) && sinceDays > 0
+                ? Date.now() - sinceDays * 86_400_000
+                : 0;
+            let db;
+            try {
+                // Read-only: this is the user's live store and OpenCode may be running.
+                db = new DatabaseSync(dbPath, { readOnly: true });
+                // Filtered in SQL rather than in JS. `time_created` is epoch ms, and
+                // the table holds thousands of rows whose `data` blobs are large — the
+                // point of the time window is not reading them at all.
+                const rows = db
+                    .prepare(`SELECT data FROM message WHERE time_created >= ${cutoffMs}`)
+                    .all();
+                for (const row of rows) {
+                    if (typeof row.data !== "string") {
+                        continue;
+                    }
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(row.data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const message = parsed;
+                    const tokens = message.tokens;
+                    if (!tokens || message.role !== "assistant") {
+                        continue;
+                    }
+                    const input = num(tokens.input);
+                    const output = num(tokens.output);
+                    const cacheRead = num(tokens.cache?.read);
+                    const cacheWrite = num(tokens.cache?.write);
+                    if (input === 0 &&
+                        output === 0 &&
+                        cacheRead === 0 &&
+                        cacheWrite === 0) {
+                        continue;
+                    }
+                    totals.requests += 1;
+                    // Added as-is: cache is disjoint from input in this store. See the
+                    // note on this module — Codex is the other way round.
+                    totals.inputTokens += input;
+                    totals.outputTokens += output;
+                    totals.cacheReadTokens += cacheRead;
+                    totals.cacheCreationTokens += cacheWrite;
+                    if (message.modelID) {
+                        models.add(message.modelID);
+                    }
+                }
+            }
+            catch (error) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                try {
+                    db?.close();
+                }
+                catch {
+                    // Closing a database that failed to open is not a second failure.
+                }
+            }
+            // Unpriced by construction rather than by a failed lookup — see the note
+            // on this module about the mixed subscription/metered provider set.
+            totals.unpricedRequests = totals.requests;
+            totals.unpricedModels = [...models].sort();
+            return {
+                cliId: CLI_ID,
+                totals,
+                filesScanned: totals.requests > 0 || errors.length === 0 ? 1 : 0,
+                errors,
+            };
+        },
+    };
+}

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

@@ -151,3 +151,21 @@ export type LocalUsageCodexSessionRollup = {
     /** token_count events where the cumulative total actually advanced. */
     billableEvents: number;
 };
+/**
+ * The slice of `node:sqlite`'s `DatabaseSync` the OpenCode reader uses.
+ *
+ * Deliberately minimal. `node:sqlite` is still flagged experimental and may
+ * change shape between Node releases, so the reader validates this much at
+ * runtime rather than trusting a type assertion — naming only what is actually
+ * called keeps that check small and honest.
+ */
+export type LocalUsageSqliteDatabase = {
+    prepare: (sql: string) => {
+        all: () => unknown[];
+    };
+    close: () => void;
+};
+/** Constructor shape for the same. */
+export type LocalUsageSqliteDatabaseCtor = new (path: string, options?: {
+    readOnly?: boolean;
+}) => LocalUsageSqliteDatabase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.20.0",
+  "version": "11.21.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": {