@juspay/neurolink 11.12.0 → 11.13.1

package/dist/types/proxy.d.ts

@@ -570,6 +570,12 @@ export type RequestLogEntry = {
     outputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    /**
+     * Provider that actually served the request, for costing. Absent on records
+     * written before this field existed; `proxyAnalysis` then falls back to a
+     * cross-provider model lookup rather than assuming Anthropic.
+     */
+    provider?: string;
     /** OTel trace ID for correlation with distributed traces */
     traceId?: string;
     /** OTel span ID for correlation with distributed traces */
@@ -1384,6 +1390,13 @@ export type ProxyRequestContext = {
     sessionId?: string;
     userAgent?: string;
     clientApp?: string;
+    /**
+     * Provider that will serve the request, used for costing. Defaults to
+     * "anthropic" when omitted, which is correct for the /v1/messages engine;
+     * the OpenAI-compatible engine must pass whatever ModelRouter resolved, or
+     * every non-Anthropic model prices to $0.
+     */
+    provider?: string;
 };
 /** Response-side details parsed from the upstream reply (model, finish, tools). */
 export type ResponseInfoContext = {
@@ -1662,7 +1675,27 @@ export type ProxyAnalysisReport = {
         cacheReadTokens: number;
         cacheCreationTokens: number;
         inputTokens: number;
+        outputTokens: number;
         requestHitRate: number | null;
+        /**
+         * Summed per-request cost in USD. Records that carry no model, or whose
+         * model matches no pricing table, contribute 0 — so this is a floor, not
+         * an exact bill. `requestsPriced` says how many records actually priced.
+         */
+        estimatedCostUsd: number;
+        requestsPriced: number;
+        /**
+         * Requests whose cost came from a longest-prefix fallback rather than an
+         * exact pricing row — the rate is inherited from a similarly-named model
+         * and may be wrong. Adding the real row makes these exact.
+         */
+        requestsPricedByPrefix: number;
+        /** Distinct models priced by prefix fallback, for the operator to chase. */
+        modelsPricedByPrefix: string[];
+        /** Requests carrying usage whose model matched no pricing row at all. */
+        requestsUnpriced: number;
+        /** Distinct models with no pricing row at all. */
+        unpricedModels: string[];
     };
     routing: {
         modes: Record<string, number>;
@@ -1698,13 +1731,45 @@ export type ProxyAnalysisFinalRequestRecord = {
     durationMs: number | null;
     account: string;
     accountType: string;
+    model: string | null;
+    provider: string | null;
     inputTokens: number | null;
+    outputTokens: number | null;
     cacheReadTokens: number | null;
     cacheCreationTokens: number | null;
     errorType: string | null;
     errorCode: string | null;
     routingDecision: ProxyAccountRoutingDecision | null;
 };
+/**
+ * A stream transformer that also handles cancellation.
+ *
+ * The Streams standard gives `Transformer` a `cancel()` callback — invoked when
+ * the stream is aborted rather than closed cleanly — and Node implements it,
+ * but TypeScript's bundled lib does not declare it yet. Without it there is no
+ * way to observe a client hanging up mid-response.
+ */
+export type ProxyCancellableTransformer<I, O> = Transformer<I, O> & {
+    cancel?: (reason?: unknown) => void;
+};
+/**
+ * Token usage scraped from a Codex (OpenAI Responses) SSE stream.
+ *
+ * Verified against real traffic: captured from a live `codex exec` run through
+ * the proxy on 2026-08-21 (`test/fixtures/codex-response-usage.sse`). The
+ * shape is `response.completed` → `response.usage`, carrying `input_tokens`,
+ * `output_tokens`, and an `input_tokens_details` object with `cached_tokens`
+ * and `cache_write_tokens`. The parser also accepts the common variants. Treat
+ * a null result as "not observed", never as "zero tokens".
+ */
+export type CodexStreamUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    /** Cache writes, which bill at a premium over both reads and plain input. */
+    cacheCreationTokens: number;
+    reasoningTokens: number;
+};
 /** Validated account-routing evidence joined to a final request log. */
 export type ProxyAnalysisRoutingRecord = {
     requestId: string;

package/dist/types/stream.d.ts

@@ -361,7 +361,7 @@ export type StreamOptions = {
     timeout?: number | string;
     /** Wall-clock cap for the whole agentic turn (ms). See GenerateOptions.turnTimeoutMs. */
     turnTimeoutMs?: number;
-    /** Max time with no progress before the turn ends as "stalled" (ms). See GenerateOptions.stallTimeoutMs. */
+    /** Max time with no progress before the turn ends as "stalled" (ms). Native Vertex loops only — see GenerateOptions.stallTimeoutMs. */
     stallTimeoutMs?: number;
     /** Remaining-time threshold that triggers the wrap-up nudge (ms). See GenerateOptions.wrapupTimeLeadMs. */
     wrapupTimeLeadMs?: number;

package/dist/utils/pricing.d.ts

@@ -14,4 +14,13 @@ export declare function calculateCost(provider: string, model: string, usage: To
  * USD price, and any caller gated by `hasPricing()` should treat them as
  * non-billable rather than zero-cost-billable.
  */
+/**
+ * Whether a model's rates came from an exact table entry or were inferred.
+ *
+ * `findRates` falls back to a longest-prefix match, so an unlisted model can
+ * silently inherit a listed one's rates — e.g. "gpt-5.6-sol" matches the
+ * "gpt-5" entry and is billed at its price. That is a guess, not a quote, and
+ * a caller reporting spend needs to be able to say which it had.
+ */
+export declare function isExactPricingMatch(provider: string, model: string): boolean;
 export declare function hasPricing(provider: string, model: string): boolean;

package/dist/utils/pricing.js

@@ -11,6 +11,47 @@
 const PRICING = {
     // Anthropic (direct API) — updated March 2026
     anthropic: {
+        // Claude 5 family. Rates from platform.claude.com/docs/en/about-claude/pricing
+        // (checked 2026-08-21). Cache multipliers are the documented ones: a 5-minute
+        // cache write is 1.25x base input, a cache hit 0.1x.
+        "claude-fable-5": {
+            input: 10.0 / 1_000_000,
+            output: 50.0 / 1_000_000,
+            cacheRead: 1.0 / 1_000_000,
+            cacheCreation: 12.5 / 1_000_000,
+        },
+        "claude-mythos-5": {
+            input: 10.0 / 1_000_000,
+            output: 50.0 / 1_000_000,
+            cacheRead: 1.0 / 1_000_000,
+            cacheCreation: 12.5 / 1_000_000,
+        },
+        "claude-opus-5": {
+            input: 5.0 / 1_000_000,
+            output: 25.0 / 1_000_000,
+            cacheRead: 0.5 / 1_000_000,
+            cacheCreation: 6.25 / 1_000_000,
+        },
+        "claude-opus-4-8": {
+            input: 5.0 / 1_000_000,
+            output: 25.0 / 1_000_000,
+            cacheRead: 0.5 / 1_000_000,
+            cacheCreation: 6.25 / 1_000_000,
+        },
+        "claude-opus-4-7": {
+            input: 5.0 / 1_000_000,
+            output: 25.0 / 1_000_000,
+            cacheRead: 0.5 / 1_000_000,
+            cacheCreation: 6.25 / 1_000_000,
+        },
+        // Sonnet 5's $2/$10 launch pricing became the standard price; the
+        // previously scheduled 2026-09-01 rise to $3/$15 was cancelled.
+        "claude-sonnet-5": {
+            input: 2.0 / 1_000_000,
+            output: 10.0 / 1_000_000,
+            cacheRead: 0.2 / 1_000_000,
+            cacheCreation: 2.5 / 1_000_000,
+        },
         // Claude 4.6 family
         "claude-opus-4-6": {
             input: 5.0 / 1_000_000,
@@ -31,6 +72,17 @@ const PRICING = {
             cacheRead: 0.3 / 1_000_000,
             cacheCreation: 3.75 / 1_000_000,
         },
+        // Undated aliases for the same models. Clients report the bare name far
+        // more often than the dated one, and without these the longest-prefix
+        // match lands on the previous generation ("claude-sonnet-4"), which both
+        // reports as an inferred rate and would silently drift if the two
+        // generations ever diverge in price.
+        "claude-sonnet-4-5": {
+            input: 3.0 / 1_000_000,
+            output: 15.0 / 1_000_000,
+            cacheRead: 0.3 / 1_000_000,
+            cacheCreation: 3.75 / 1_000_000,
+        },
         "claude-opus-4-5": {
             input: 5.0 / 1_000_000,
             output: 25.0 / 1_000_000,
@@ -43,6 +95,12 @@ const PRICING = {
             cacheRead: 0.1 / 1_000_000,
             cacheCreation: 1.25 / 1_000_000,
         },
+        "claude-haiku-4-5": {
+            input: 1.0 / 1_000_000,
+            output: 5.0 / 1_000_000,
+            cacheRead: 0.1 / 1_000_000,
+            cacheCreation: 1.25 / 1_000_000,
+        },
         // Claude 4.0/4.1 family
         "claude-opus-4-1": {
             input: 15.0 / 1_000_000,
@@ -147,6 +205,35 @@ const PRICING = {
     },
     // OpenAI — updated March 2026
     openai: {
+        // GPT-5.6 family (Sol/Terra/Luna). Rates reflect OpenAI's 2026-07-30 cut,
+        // which reduced Luna by 80% and Terra by 20%; Sol was unchanged. Many
+        // third-party tables still carry the pre-cut numbers.
+        // List rates. Note that some resellers advertise sol at 50% off
+        // ($2.50/$15.00/$0.25); those are promotional and expire, so the table
+        // carries list price and cache read stays the documented 0.1x of input.
+        "gpt-5.6-sol": {
+            input: 5.0 / 1_000_000,
+            output: 30.0 / 1_000_000,
+            cacheRead: 0.5 / 1_000_000,
+            cacheCreation: 6.25 / 1_000_000,
+        },
+        "gpt-5.6-terra": {
+            input: 2.0 / 1_000_000,
+            output: 12.0 / 1_000_000,
+            cacheRead: 0.2 / 1_000_000,
+            cacheCreation: 2.5 / 1_000_000,
+        },
+        "gpt-5.6-luna": {
+            input: 0.2 / 1_000_000,
+            output: 1.2 / 1_000_000,
+            cacheRead: 0.02 / 1_000_000,
+            cacheCreation: 0.25 / 1_000_000,
+        },
+        "gpt-5.5": {
+            input: 5.0 / 1_000_000,
+            output: 30.0 / 1_000_000,
+            cacheRead: 0.5 / 1_000_000,
+        },
         // GPT-5.x family
         // cacheRead = 0.25x input (cached input tokens; no separate cacheCreation).
         "gpt-5.4": {
@@ -625,7 +712,30 @@ const PROVIDER_ALIASES = {
  *
  * @returns The rate entry, or undefined when the combination is unknown.
  */
-function findRates(provider, model) {
+/**
+ * Whether the tail left over after a longest-prefix match is only a version or
+ * date stamp — e.g. "claude-sonnet-4-5-20250929-v1:0" against the table key
+ * "claude-sonnet-4-5". That is the *same* model carrying a release suffix, so
+ * its rate is quoted, not inferred.
+ *
+ * Deliberately narrow: "gpt-5.6-sol" against "gpt-5" leaves ".6-sol", which is
+ * a different model generation and stays flagged as inferred.
+ */
+const VERSION_SUFFIX_RE = /^[-@](\d{8}|v\d+(:\d+)?|latest)([-@:](\d{8}|v\d+(:\d+)?))*$/;
+function isVersionOnlySuffix(model, key) {
+    if (!model.startsWith(key) || model === key) {
+        return false;
+    }
+    return VERSION_SUFFIX_RE.test(model.slice(key.length));
+}
+function findRates(provider, model, 
+/**
+ * Set to true when the rates came from a literal table key rather than a
+ * prefix/fallback match. Threaded as an out-param so there is exactly one
+ * lookup implementation — a second hand-written copy drifted from this one
+ * and mislabelled every Bedrock and Vertex-Gemini hit.
+ */
+matchKind) {
     const stripped = provider.toLowerCase().replace(/[^a-z]/g, "");
     const normalizedProvider = PROVIDER_ALIASES[stripped] ?? stripped;
     // Proxy providers (LiteLLM, OpenRouter): search all known providers for a model match
@@ -633,6 +743,9 @@ function findRates(provider, model) {
         for (const providerPricing of Object.values(PRICING)) {
             // Exact match
             if (providerPricing[model]) {
+                if (matchKind) {
+                    matchKind.exact = true;
+                }
                 return providerPricing[model];
             }
             const sortedKeys = Object.keys(providerPricing).sort((a, b) => b.length - a.length);
@@ -667,6 +780,9 @@ function findRates(provider, model) {
         : model;
     // Exact match
     if (providerPricing[modelKey]) {
+        if (matchKind) {
+            matchKind.exact = true;
+        }
         return providerPricing[modelKey];
     }
     // Longest-prefix match (skip the synthetic "_default" sentinel below)
@@ -675,6 +791,9 @@ function findRates(provider, model) {
         .sort((a, b) => b.length - a.length);
     const key = sortedKeys.find((k) => modelKey.startsWith(k));
     if (key) {
+        if (matchKind && isVersionOnlySuffix(modelKey, key)) {
+            matchKind.exact = true;
+        }
         return providerPricing[key];
     }
     // Fallback: Vertex hosts both Claude and Gemini models.
@@ -686,6 +805,9 @@ function findRates(provider, model) {
         const googlePricing = PRICING["google"];
         if (googlePricing) {
             if (googlePricing[model]) {
+                if (matchKind) {
+                    matchKind.exact = true;
+                }
                 return googlePricing[model];
             }
             const googleKeys = Object.keys(googlePricing).sort((a, b) => b.length - a.length);
@@ -742,6 +864,19 @@ export function calculateCost(provider, model, usage) {
  * USD price, and any caller gated by `hasPricing()` should treat them as
  * non-billable rather than zero-cost-billable.
  */
+/**
+ * Whether a model's rates came from an exact table entry or were inferred.
+ *
+ * `findRates` falls back to a longest-prefix match, so an unlisted model can
+ * silently inherit a listed one's rates — e.g. "gpt-5.6-sol" matches the
+ * "gpt-5" entry and is billed at its price. That is a guess, not a quote, and
+ * a caller reporting spend needs to be able to say which it had.
+ */
+export function isExactPricingMatch(provider, model) {
+    const matchKind = { exact: false };
+    const rates = findRates(provider, model, matchKind);
+    return rates !== undefined && matchKind.exact;
+}
 export function hasPricing(provider, model) {
     const rates = findRates(provider, model);
     if (!rates) {

package/docs-site/mcp-server/search.js

@@ -1,5 +1,4 @@
 import MiniSearch from "minisearch";
-
 const MINISEARCH_CONFIG = {
   fields: ["title", "description", "content", "tags"],
   storeFields: ["title", "description", "section", "path"],
@@ -9,31 +8,44 @@ const MINISEARCH_CONFIG = {
     prefix: true,
   },
 };
-
 export class DocsSearch {
   miniSearch;
   documents = new Map();
   sections = new Map();
-
   constructor() {
     this.miniSearch = new MiniSearch(MINISEARCH_CONFIG);
   }
-
   loadIndex(indexData) {
     this.documents.clear();
     this.sections.clear();
     this.miniSearch = new MiniSearch(MINISEARCH_CONFIG);
-    for (const doc of indexData.documents) {
-      this.documents.set(doc.id, doc);
+    // indexData is a flat array: one record per page plus one per heading
+    // anchor on that page (url contains "#..."). Normalize every record to
+    // IndexDocument so search() covers page and anchor text alike, but only
+    // keep the page-level ones (no "#" in path) for the page map / sections
+    // that get_page, list_sections and get_by_section rely on.
+    const normalized = indexData.map((raw) => ({
+      id: raw.objectID,
+      title: raw.title,
+      description: "",
+      content: raw.content ?? "",
+      section: (raw.hierarchy?.lvl0 ?? "").toLowerCase(),
+      tags: [],
+      path: raw.url.replace(/^\/docs\//, ""),
+    }));
+    for (const doc of normalized) {
+      if (doc.path.includes("#")) {
+        continue;
+      }
+      this.documents.set(doc.path, doc);
     }
     for (const doc of this.documents.values()) {
       const sectionDocs = this.sections.get(doc.section) || [];
       sectionDocs.push(doc);
       this.sections.set(doc.section, sectionDocs);
     }
-    this.miniSearch.addAll(Array.from(this.documents.values()));
+    this.miniSearch.addAll(normalized);
   }
-
   search(query, limit = 10, section) {
     const options = section
       ? {
@@ -50,14 +62,12 @@ export class DocsSearch {
       score: r.score,
     }));
   }
-
   getPage(docPath) {
     return (
       this.documents.get(docPath) ||
       this.documents.get(docPath.replace(/^\//, ""))
     );
   }
-
   listSections() {
     const result = [];
     for (const [name, docs] of this.sections) {
@@ -69,11 +79,9 @@ export class DocsSearch {
     }
     return result.sort((a, b) => a.name.localeCompare(b.name));
   }
-
   getBySection(section) {
     return this.sections.get(section) || [];
   }
-
   get documentCount() {
     return this.documents.size;
   }

package/docs-site/mcp-server/types.d.ts

@@ -7,12 +7,19 @@ export type IndexDocument = {
     tags: string[];
     path: string;
 };
-export type SearchIndex = {
-    version: number;
-    generatedAt: string;
-    documentCount: number;
-    documents: IndexDocument[];
+export type RawSearchRecord = {
+    objectID: string;
+    title: string;
+    url: string;
+    content?: string;
+    hierarchy: {
+        lvl0?: string;
+        lvl1?: string;
+        lvl2?: string;
+        lvl3?: string;
+    };
 };
+export type SearchIndex = RawSearchRecord[];
 export type SearchResult = {
     id: string;
     title: string;