@juspay/neurolink 12.45.1 → 12.45.2

package/dist/localUsage/cursorReader.js

@@ -86,11 +86,16 @@ function decodeMessage(buf) {
                 return null;
             }
             // Beyond 2^53 a JS number stops being exact, and a token count that
-            // silently loses precision is worse than a refused parse.
+            // silently loses precision is worse than a refused parse. The shift
+            // guard is only the cheap early exit: the eighth byte (shift 49) passes
+            // it and can still carry the sum past Number.MAX_SAFE_INTEGER.
             if (shift > 53) {
                 return null;
             }
             result += (byte & 0x7f) * Math.pow(2, shift);
+            if (!Number.isSafeInteger(result)) {
+                return null;
+            }
             shift += 7;
             if ((byte & 0x80) === 0) {
                 return result;
@@ -269,6 +274,32 @@ function findBreakdownTotal(buf, depth) {
 export function extractCursorContextTokens(rootBlob) {
     return findBreakdownTotal(rootBlob, 0);
 }
+/**
+ * The root blob id a store's meta row points at, or `undefined` when the row is
+ * not hex-encoded JSON carrying a string `latestRootBlobId`.
+ */
+function readLatestRootBlobId(rawMeta) {
+    // Hex-encoded JSON. Validated rather than assumed: a non-hex value decodes to
+    // mojibake and would throw inside JSON.parse anyway, but the explicit test
+    // says why the buffer conversion is there.
+    if (!/^(?:[0-9a-fA-F]{2})+$/.test(rawMeta)) {
+        return undefined;
+    }
+    try {
+        const meta = JSON.parse(Buffer.from(rawMeta, "hex").toString("utf8"));
+        if (typeof meta === "object" &&
+            meta !== null &&
+            "latestRootBlobId" in meta &&
+            typeof meta.latestRootBlobId ===
+                "string") {
+            return meta.latestRootBlobId;
+        }
+    }
+    catch {
+        // Not JSON: reported by the caller, which cannot tell this from a missing id.
+    }
+    return undefined;
+}
 /** `~/.cursor/chats/<workspaceHash>/<agentId>/store.db`, two levels down. */
 async function findStoreDatabases() {
     const root = chatsRoot();
@@ -380,30 +411,31 @@ export async function createCursorReader() {
                     const metaRows = db.prepare("SELECT value FROM meta").all();
                     const rawMeta = metaRows.find((row) => typeof row.value === "string")?.value;
                     if (rawMeta === undefined) {
-                        continue;
-                    }
-                    // Hex-encoded JSON. Validated rather than assumed: a non-hex value
-                    // decodes to mojibake and would throw inside JSON.parse anyway, but
-                    // the explicit test says why the buffer conversion is there.
-                    if (!/^(?:[0-9a-fA-F]{2})+$/.test(rawMeta)) {
-                        continue;
-                    }
-                    let latestRootBlobId;
-                    try {
-                        const meta = JSON.parse(Buffer.from(rawMeta, "hex").toString("utf8"));
-                        if (typeof meta === "object" &&
-                            meta !== null &&
-                            "latestRootBlobId" in meta &&
-                            typeof meta
-                                .latestRootBlobId === "string") {
-                            latestRootBlobId = meta
-                                .latestRootBlobId;
+                        if (metaRows.length === 0) {
+                            // A store a session has only just created: no meta row yet. That
+                            // is a new session, not a format change.
+                            continue;
                         }
-                    }
-                    catch {
+                        // A row is there but holds no text (NULL or a BLOB): the store was
+                        // opened and counted, so this is reported like any other meta row
+                        // that cannot be read.
+                        errors.push({
+                            cliId: CLI_ID,
+                            filePath: dbPath,
+                            message: "meta row holds no text value — Cursor's on-disk format has likely changed",
+                        });
                         continue;
                     }
+                    const latestRootBlobId = readLatestRootBlobId(rawMeta);
                     if (latestRootBlobId === undefined) {
+                        // Reported, never silently skipped, for the same reason as the
+                        // missing breakdown below: a store opened and counted in
+                        // filesScanned that yields nothing must not read as "used nothing".
+                        errors.push({
+                            cliId: CLI_ID,
+                            filePath: dbPath,
+                            message: "meta row is not hex-encoded JSON carrying a latestRootBlobId — Cursor's on-disk format has likely changed",
+                        });
                         continue;
                     }
                     const blobRows = db

package/dist/localUsage/grokReader.d.ts

@@ -24,7 +24,9 @@
  * `modelUsage` map and `numTurns`. A turn that failed before any model call
  * carries no `usage` at all, so it excludes itself. `stop_reason` is not an
  * eligibility test: a truncated or interrupted turn with a usage object was
- * still billed.
+ * still billed. A `usage` that is present but is not that ledger (empty, an
+ * array, none of the counters) is a changed format: it is reported, not billed
+ * as a request of zero tokens.
  *
  * What the numbers MEAN took a second real turn to settle, and the answer is
  * neither "per turn" nor "cumulative" but both, by process:

package/dist/localUsage/grokReader.js

@@ -24,7 +24,9 @@
  * `modelUsage` map and `numTurns`. A turn that failed before any model call
  * carries no `usage` at all, so it excludes itself. `stop_reason` is not an
  * eligibility test: a truncated or interrupted turn with a usage object was
- * still billed.
+ * still billed. A `usage` that is present but is not that ledger (empty, an
+ * array, none of the counters) is a changed format: it is reported, not billed
+ * as a request of zero tokens.
  *
  * What the numbers MEAN took a second real turn to settle, and the answer is
  * neither "per turn" nor "cumulative" but both, by process:
@@ -189,6 +191,24 @@ function continuesRun(prev, next) {
         next.cacheCreation >= prev.cacheCreation &&
         next.calls >= prev.calls);
 }
+const USAGE_COUNTERS = ["inputTokens", "outputTokens", "modelCalls"];
+/**
+ * Whether `usage` is shaped like the ledger Grok writes: an object, not an
+ * array, with at least one of the counters a turn that reached a model always
+ * carries. `count()` reads any missing field as 0, so without this a `{}`, a
+ * `[]` or the same counters under renamed keys passed as a turn of zero tokens
+ * and was billed as one request.
+ */
+function isTurnUsage(usage) {
+    if (typeof usage !== "object" || usage === null || Array.isArray(usage)) {
+        return false;
+    }
+    const record = usage;
+    // `1e999` parses as Infinity, which is a number but not a count: `count()`
+    // reads it as 0, so one such field made a malformed turn a zero-token request.
+    const counters = USAGE_COUNTERS.map((key) => record[key]).filter((value) => typeof value === "number");
+    return counters.length > 0 && counters.every(Number.isFinite);
+}
 function completedTurn(parsed) {
     if (typeof parsed !== "object" || parsed === null) {
         return null;
@@ -208,7 +228,7 @@ function completedTurn(parsed) {
     if (u.sessionUpdate !== "turn_completed") {
         return null;
     }
-    if (typeof u.usage !== "object" || u.usage === null) {
+    if (u.usage === undefined || u.usage === null) {
         // Completed without reaching a model — an error before the first call.
         return null;
     }
@@ -217,10 +237,11 @@ function completedTurn(parsed) {
         usage: u.usage,
     };
 }
-async function foldStream(filePath, totals, unpriced) {
+async function foldStream(filePath, totals, unpriced, errors) {
     // Insertion-ordered, so the delta rule below sees turns in the order Grok
     // wrote them, with a re-emitted prompt replacing its earlier record.
     const turns = new Map();
+    let unrecognised = 0;
     const rl = createInterface({
         input: createReadStream(filePath, { encoding: "utf8" }),
         crlfDelay: Infinity,
@@ -244,12 +265,30 @@ async function foldStream(filePath, totals, unpriced) {
             if (turn === null) {
                 continue;
             }
+            if (!isTurnUsage(turn.usage)) {
+                unrecognised += 1;
+                // The later record for a prompt replaces the earlier one, so one that
+                // cannot be read must not leave the earlier reading in the totals.
+                if (turn.promptId !== undefined) {
+                    turns.delete(turn.promptId);
+                }
+                continue;
+            }
             turns.set(turn.promptId ?? `line:${lineNo}`, readTurn(turn.usage));
         }
     }
     finally {
         rl.close();
     }
+    if (unrecognised > 0) {
+        // One entry per stream: a changed format hits every turn in the file, and
+        // an entry each would bury everything else a scan has to report.
+        errors.push({
+            cliId: CLI_ID,
+            filePath,
+            message: `${unrecognised} completed turn(s) carried a usage record with no recognisable token or call counter — Grok Build's stream format has likely changed`,
+        });
+    }
     let prev;
     for (const turn of turns.values()) {
         const delta = prev !== undefined && continuesRun(prev, turn)
@@ -307,7 +346,7 @@ export async function createGrokReader() {
                     if (cutoff !== undefined && (await stat(file)).mtimeMs < cutoff) {
                         continue;
                     }
-                    await foldStream(file, totals, unpriced);
+                    await foldStream(file, totals, unpriced, errors);
                     filesScanned += 1;
                 }
                 catch (error) {

package/dist/localUsage/hermesReader.d.ts

@@ -27,7 +27,9 @@
  * therefore the complete record of what Hermes actually sent to a provider,
  * and this reader sums them. The `sessions` aggregate is read only for a
  * session that has no usage rows at all (a store older than the migration
- * that introduced the table), and never in addition to them.
+ * that introduced the table), and never in addition to them. A usage table
+ * that exists but lacks a required column is a changed schema, and is reported
+ * rather than read around.
  *
  * Cost: Hermes records `estimated_cost_usd` with a `cost_status` of
  * `estimated`, from its own pricing snapshot. That is a modeled figure and is

package/dist/localUsage/hermesReader.js

@@ -27,7 +27,9 @@
  * therefore the complete record of what Hermes actually sent to a provider,
  * and this reader sums them. The `sessions` aggregate is read only for a
  * session that has no usage rows at all (a store older than the migration
- * that introduced the table), and never in addition to them.
+ * that introduced the table), and never in addition to them. A usage table
+ * that exists but lacks a required column is a changed schema, and is reported
+ * rather than read around.
  *
  * Cost: Hermes records `estimated_cost_usd` with a `cost_status` of
  * `estimated`, from its own pricing snapshot. That is a modeled figure and is
@@ -235,7 +237,19 @@ function readStore(db, dbPath, cutoffSeconds, totals, unpriced, errors) {
         return;
     }
     const usageCols = columnsOf(db, "session_model_usage");
-    const hasUsage = usageCols.size > 0 && USAGE_REQUIRED.every((c) => usageCols.has(c));
+    const missingUsage = USAGE_REQUIRED.filter((c) => !usageCols.has(c));
+    if (usageCols.size > 0 && missingUsage.length > 0) {
+        // Fail closed, for the same reason as above. The table exists, so this is
+        // not a store older than the migration; falling back to the sessions
+        // aggregate would silently drop every non-primary task.
+        errors.push({
+            cliId: CLI_ID,
+            filePath: dbPath,
+            message: `session_model_usage table lacks required column(s) ${missingUsage.join(", ")} — Hermes' schema has changed`,
+        });
+        return;
+    }
+    const hasUsage = usageCols.size > 0;
     // Last activity, in seconds. Sessions know theirs; usage rows fall back to
     // their session's when they carry no `last_seen` of their own.
     const sessionAt = [

package/dist/providers/litellm/client.js

@@ -242,7 +242,7 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         return (process.env.LITELLM_FALLBACK_MODELS?.split(",")
             .map((m) => m.trim())
             .filter((m) => m.length > 0) || [
-            "openai/gpt-4o",
+            "openai/gpt-5.4",
             "anthropic/claude-haiku-4-5-20251001",
             "meta-llama/llama-3.1-8b-instruct",
             "google/gemini-2.5-flash",

package/docs-site/static/search-index.json

@@ -9610,7 +9610,7 @@
 {"objectID":"6bfda42431fee55d45b08f169983782641ed449c8f73abe19f2f3c421f8666cb","title":"Credential-free provider acceptance gate","url":"/docs/provider-integration/acceptance-gate#credential-free-provider-acceptance-gate","content":"Suite: test/continuous-test-suite-acceptance-gate.ts\nRun: pnpm run test:acceptance-gate\nScript: test:acceptance-gate in package.json\nMock server: test/helpers/acceptanceGateServer.ts","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Credential-free provider acceptance gate","lvl3":""}},
 {"objectID":"3ebd78a77f6b62003d9706d1608fb7eded2399f0dbd78b3964e14d5ac3d31f90","title":"Why this exists","url":"/docs/provider-integration/acceptance-gate#why-this-exists","content":"The prior full provider capability matrix (test/continuous-test-suite-provider-matrix.ts,\n1,037 cells) was audited and found to be able to report green without proving\nanything, in at least 10 ways: tool cells that passed with zero tool calls\nmade, no disableInternalFallback and no provider/model identity check on\nany cell, structured-output cells that asserted a value's type rather than\nits contents, and a harness that could exit 0 on zero coverage.\n\nThis gate replaces that surface area with a small, falsifiable one: at most\n9 cells per (provider, pinned model), fail-fast, cheapest first, run\nentirely against a local mock vendor HTTP server — no real vendor calls, no\nreal API keys, ever. Every provider is pointed at the mock through its own\ndocumented base-URL environment override, with a fake key, so the SDK and\nthe CLI both round-trip through the exact same server (that's what makes\ncell 9, CLI parity, meaningful instead of a re-derivation).","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Why this exists","lvl3":""}},
 {"objectID":"0d725f9afdd86b7d8821e0e94ea518e7d06ef55da79a6781a8c9b96d17125ed8","title":"The 9 cells","url":"/docs/provider-integration/acceptance-gate#the-9-cells","content":"Each cell asserts an exact value the mock server returns, never a shape\nor a \"non-empty\" check. A row stops (remaining cells report SKIP, not a\nsecond FAIL) the first time a cell genuinely fails — this is the\n\"fail-fast\" contract; a capability-gated skip (e.g. a provider that doesn't\ndeclare tools) never counts as a failure and never poisons the rest of the\nrow.\nIdentity pin — every call carries\n   { provider, model, disableInternalFallback: true }; the result's\n   provider and model fields are asserted against what was requested.\nExact-output generate — generate()'s content is asserted equal to\n   a specific constant (GATE_EXACT_VALUE), not merely non-empty.\nDrained stream, identity asserted — the stream is fully drained and\n   the accumulated content is asserted equal to a constant. The\n   StreamResult's provider/model are then asserted — and for the\n   OpenAI-compatible protocol rows, against what the mock server actually\n   served (${model}::mock-server-resolved), not what was requested. See\n   \"The stream-identity defect\" below — this cell is the reason that defect\n   was caught and fixed.\nTool-nonce proof — the test tool's execute() returns a fresh\n   randomUUID() nonce that exists nowhere else. The final answer is\n   asserted to contain ACCEPTANCE_GATE_TOOL_CONFIRMED:<nonce>, which the\n   mock server only emits once it sees that exact nonce echoed back in a\n   tool-result message — i.e. the assertion can only pass if a real tool\n   call round-tripped through the model.\nStructured-exact — generate({ schema })'s parsed structuredData is\n   asserted equal (via JSON.stringify) to an exact object, and\n   jsonTruncated is asserted not true — truncation is surfaced, never\n   silently swallowed.\nThinking proof — only for providers whose catalog/descriptor declares\n   thinking: true (currently anthropic and the deepseek catalog row).\n   Drives stream() with an explicit\n   thinkingConfig: { enabled: true, budgetTokens: 2048 } (the SDK path has no bare thinkingLevel\n   ","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"The 9 cells","lvl3":""}},
-{"objectID":"9e86b70c4ede7dc96da001ab3bf0327c39f525d7d1c62279bcf34ae41f54229a","title":"Known, documented gap in cell 9","url":"/docs/provider-integration/acceptance-gate#known-documented-gap-in-cell-9","content":"The CLI's generate/stream commands have no flag that reaches\ndisableInternalFallback — commandFactory.ts's processOptions()\nwhitelist omits it (only the interactive REPL's separate options schema\nsupports it). Cell 9 therefore runs without disableInternalFallback. This\nis an intentional, documented gap, not an oversight: fixing it is a CLI\noption-surface change out of scope for this gate.\n\nWhat keeps the gap harmless is that the suite holds no real credential to\nfall back to. test/helpers/credentialFreeEnv.ts is its first import: it\npoints DOTENV_CONFIG_PATH at /dev/null, so neither the SDK's nor the\nharness's .env load reads a developer's .env, it deletes every\ncredential-named variable the shell exported, and it points HOME at an\nempty temp directory. The last one matters as much as the first two: the\nAnthropic provider prefers a stored OAuth token\n(~/.neurolink/anthropic-credentials.json) over ANTHROPIC_API_KEY and\nrefreshes it against Anthropic's live token endpoint, so a gate that only\ncleaned the environment could still send a real refresh token to a real\nhost. The suite checks the environment and the home directory before it\nruns a row, and the CLI child inherits that stripped environment plus the\ncurrent row's fake key.","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Known, documented gap in cell 9","lvl3":""}},
+{"objectID":"9e86b70c4ede7dc96da001ab3bf0327c39f525d7d1c62279bcf34ae41f54229a","title":"Known, documented gap in cell 9","url":"/docs/provider-integration/acceptance-gate#known-documented-gap-in-cell-9","content":"The CLI's generate/stream commands have no flag that reaches\ndisableInternalFallback — commandFactory.ts's processOptions()\nwhitelist omits it (only the interactive REPL's separate options schema\nsupports it). Cell 9 therefore runs without disableInternalFallback. This\nis an intentional, documented gap, not an oversight: fixing it is a CLI\noption-surface change out of scope for this gate.\n\nWhat keeps the gap harmless is that the suite holds no real credential to\nfall back to. test/helpers/credentialFreeEnv.ts is its first import: it\npoints DOTENV_CONFIG_PATH at /dev/null, so neither the SDK's nor the\nharness's .env load reads a developer's .env, it deletes every\ncredential-named variable the shell exported (including secrets whose names the\nplain API-key and token words miss: service-account and private keys, speech\nkeys, OTLP exporter headers, a Redis URL, an auth config blob, the ssh-agent\nsocket) together with the ambient *_BASE_URL, *_ENDPOINT,\nOTLP exporter and AWS_PROFILE overrides that could point a cell somewhere\nother than the mock server, and it points HOME at an empty temp directory.\nThe last one matters as much as the first two: the\nAnthropic provider prefers a stored OAuth token\n(~/.neurolink/anthropic-credentials.json) over ANTHROPIC_API_KEY and\nrefreshes it against Anthropic's live token endpoint, so a gate that only\ncleaned the environment could still send a real refresh token to a real\nhost. The suite checks the environment and the home directory before it\nruns a row, and the CLI child inherits that stripped environment plus the\ncurrent row's fake key. Because that check reuses the strip's own pattern, the\nsuite also plants a literal list of dummy secret and endpoint variables\n(test/helpers/ambientSecretCanaries.ts) before the strip runs and fails if\nany survives, so a name the pattern misses cannot pass unnoticed.","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Known, documented gap in cell 9","lvl3":""}},
 {"objectID":"d7fd57b5311bed74e1ac06949abeca0fc2aab02f46c7841d85da59920aafcd61","title":"The stream-identity defect (cell 3)","url":"/docs/provider-integration/acceptance-gate#the-stream-identity-defect-cell-3","content":"Confirmed and fixed in src.\n\nStreamResult.model (the public value cell 3 asserts against) was reporting\nthe requested model, not the model the server actually served. Internally,\nneurolink.ts already captured the resolved model — the bug was that this\nresolved value never reached the public StreamResult.\nOpenAI-compatible protocol path (src/lib/providers/openaiChatCompletionsBase.ts,\n  src/lib/types/openaiCompatible.ts) — the substantive fix, and the one\n  cell 3 actually exercises: added StreamLoopArgs.onModelObserved?: (model:\nstring) => void, fired once per step that echoes a model field on the\n  wire (SSE chunk.model, captured by parseSSEStream into\n  OpenAICompatSSEResult.model). executeStream's public result.model was\n  a plain data property fixed at the pre-call resolved/requested modelId;\n  it is now a live getter (observedServerModel ?? modelId) so a caller\n  reading .model after draining .stream sees what the server actually\n  served — the mock's ::mock-server-resolved suffix on the STREAM cell\n  is what makes this difference observable and the fix provable. It has to\n  be a getter, not a reassignment after the fact: preserveLiveStreamAccessors\n  spreads result into a new object at each provider boundary before the\n  background loop produces its first chunk, which would freeze a plain field\n  at its construction-time value.\nAnthropic path (src/lib/providers/anthropic/client.ts) — a narrower,\n  related fix: StreamResult.model was reporting the raw constructor\n  argument this.modelName, which is undefined whenever a caller relies\n  on the default model rather than passing one explicitly. It now reports\n  modelId, the value already resolved as this.modelName ||\ngetDefaultAnthropicModel() and actually put on the wire. Note this is a\n  different bug from the OpenAI-compatible one: the Anthropic Messages API\n  always echoes the request's model back verbatim in its envelope, so\n  there is no \"server resolved a different model than requested\" case on\n  this protoc","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"The stream-identity defect (cell 3)","lvl3":""}},
 {"objectID":"d47c3d7913d5adb6968b60f5025f7c15472e8bbf76abe5b0b4277001a96c9691","title":"Additional src defects found and fixed by cells 4 and 8","url":"/docs/provider-integration/acceptance-gate#additional-src-defects-found-and-fixed-by-cells-4-and-8","content":"Building this gate surfaced three more real defects, all in provider-side\ntool-capability allowlists and one test-sizing constant — none in the mock\nitself. Each is a one-line, strictly capability-adding fix.\nollama cell 4 (tool-nonce proof) — OllamaProvider.supportsTools()\n  checks the model name against modelConfiguration.ts's\n  createOllamaConfig().modelBehavior.toolCapableModels allowlist. That list\n  (OLLAMA_TOOL_CAPABLE_MODELS) included \"llama3.1\" but not \"llama3.2\" —\n  the gate's own pinned default Ollama model\n  (providerMatrix.ts's ollama.defaultModel, which declares tools:\ntrue). supportsTools() returned false for the provider's own default\n  model, which silently dropped the user-supplied tool from both the\n  wire tools field and the execution lookup (executeNativeGenerate()'s\n  toolsRecord is built empty when supportsTools() is false), producing a\n  \"Tool not found\" error instead of a real tool round-trip. Fixed in\n  src/lib/core/modelConfiguration.ts by adding \"llama3.2\" to the default\n  toolCapableModels array.\nopenrouter cell 4 (tool-nonce proof) — OpenRouterProvider.supportsTools()\n  has two paths: a dynamically cached capability set (populated by\n  cacheModelCapabilities(), which fetches /models and reads\n  supported_parameters) and a hardcoded fallback pattern list used until\n  that cache is populated. cacheModelCapabilities() is never invoked\n  automatically anywhere in the real generate()/stream() code paths, so\n  the fallback list is the only path ever exercised in practice. That list\n  included \"meta-llama/llama-3.2\" and \"meta-llama/llama-3.3\" but not\n  \"meta-llama/llama-3.1\" — the family of the gate's pinned default\n  OpenRouter model, \"meta-llama/llama-3.1-8b-instruct\" (chosen, per an\n  existing code comment, specifically because it supports every capability\n  the matrix exercises). Same failure mode as the ollama defect above.\n  Fixed in src/lib/providers/openRouter/client.ts by adding\n  \"meta-llama/llama-3.1\" to knownToolCapablePatterns.\nli","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Additional src defects found and fixed by cells 4 and 8","lvl3":""}},
 {"objectID":"0618b382f27d4d7ae674f8c803a793a4b1774ab7eecc3e1eb4738979361454ff","title":"Mock server","url":"/docs/provider-integration/acceptance-gate#mock-server","content":"test/helpers/acceptanceGateServer.ts is a real node:http server (not\nfetch interception) that speaks the two wire protocols the covered providers\nactually use:\nOpenAI-compatible chat completions — /chat/completions (including\n  SSE streaming, tool calls, response_format, reasoning deltas), /models,\n  /embeddings.\nAnthropic Messages API — /messages, for the one ANTHROPIC_BASE_URL\n  row.\n\nEvery provider is redirected at it through its own documented base-URL\nenvironment override (<ID>_BASE_URL for catalog providers, each\nhand-written provider's own env var — see \"Coverage\" below) with a fake API\nkey (gate-fake-key-not-a-real-credential). The server enforces a\nrequest-count ceiling per instance and returns HTTP 400 past it (cell 8).\n\nEvery gate marker, exact value, and mock behavior the suite asserts against\nis exported from that file (GATE_MARKERS, GATE_EXACT_VALUE,\nGATE_STREAM_VALUE, GATE_STRUCTURED_VALUE, GATE_TOOL_NAME,\nGATE_TOOL_CONFIRM_PREFIX, GATE_THINKING_FULL, GATE_THINKING_ANSWER,\nGATE_EMBEDDING_VECTOR, GATE_SERVER_MODEL_SUFFIX, ...) so the suite and\nthe mock can never silently drift apart.","hierarchy":{"lvl0":"Provider Integration","lvl1":"Credential-free provider acceptance gate","lvl2":"Mock server","lvl3":""}},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.45.1",
+  "version": "12.45.2",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -196,9 +196,9 @@
     "// CI tier — fast, no live AI calls, safe for every commit (test:unit; also see the separate provider-safety-net CI job, which runs build + test:providers-mocked + test:provider-structure + test:error-classifier-contract on every PR)": "",
     "test:tool-routing": "pnpm exec tsx test/continuous-test-suite-tool-routing.ts",
     "test:tool-routing-semantic": "pnpm exec tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:classifier-router && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:mcp-direct-name-repair && pnpm run test:mcp-breaker-resolved-errors && pnpm run test:model-not-found-retryable && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:image-exif && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp && pnpm run test:retired-model-defaults",
+    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:classifier-router && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:mcp-direct-name-repair && pnpm run test:mcp-breaker-resolved-errors && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:image-exif && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp && pnpm run test:retired-model-defaults",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit; test:matrix, a different suite covering the full provider capability matrix, runs nightly via .github/workflows/live-matrix.yml — test:providers itself is still only wired into test:live, not any GitHub Actions workflow)": "",
-    "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
+    "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic && pnpm run test:model-not-found-retryable",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run (not wired into any GitHub Actions workflow as of this comment; run manually or add to live-matrix.yml if nightly coverage is needed)": "",
     "test:product": "pnpm run test:media && pnpm run test:tts && pnpm run test:ppt && pnpm run test:proxy",
     "test:performance": "tsx tools/testing/performanceMonitor.ts",