@juspay/neurolink 13.0.3 → 13.1.1

package/dist/providers/decide/baseUrl.js

@@ -22,6 +22,32 @@ const TRANSFORMS = {
 export function normalizeBaseURL(raw, transforms) {
     return transforms.reduce((value, name) => TRANSFORMS[name](value), raw);
 }
+/**
+ * The three spellings the rest of the SDK treats as this machine (the OTLP log
+ * sink, proxy replay and native telemetry use the same list). It is exact on
+ * purpose: `new URL()` has already folded `0x7f.1` and `2130706433` into
+ * `127.0.0.1` and lowercased the host, and the rest of 127/8, `0.0.0.0` and
+ * `*.localhost` are not loopback here.
+ */
+const LOOPBACK_HOSTS = new Set([
+    "localhost",
+    "127.0.0.1",
+    "[::1]",
+]);
+/** Whether a `URL.hostname` is this machine, so a plain-http request to it never leaves it. */
+export function isLoopbackHost(hostname) {
+    return LOOPBACK_HOSTS.has(hostname);
+}
+/**
+ * Why a parsed base URL may not be used, or undefined: a plain-http URL that
+ * is not loopback would send the bearer key and the decision body in cleartext.
+ * The message names no part of the URL.
+ */
+export function cleartextBaseURLProblem(url, displayName, fix) {
+    return url.protocol === "http:" && !isLoopbackHost(url.hostname)
+        ? `The ${displayName} base URL must use https:// unless it points at this machine (localhost, 127.0.0.1 or [::1]). ${fix}`
+        : undefined;
+}
 const SHAPE_CHECKS = {
     // None of these messages repeats the base URL: it can hold a credential,
     // `fetch` rejects userinfo and echoes it, and a route appended after a query
@@ -35,6 +61,11 @@ const SHAPE_CHECKS = {
             if (url.protocol !== "https:" && url.protocol !== "http:") {
                 return `The ${displayName} base URL must start with https:// or http://. ${fix}`;
             }
+            // A cleartext request would carry the bearer key and the decision body.
+            const cleartext = cleartextBaseURLProblem(url, displayName, fix);
+            if (cleartext) {
+                return cleartext;
+            }
             // The raw text is checked as well: `search` and `hash` are empty for a
             // lone "?" or "#", which still swallows the route appended after it.
             return url.username ||

package/dist/providers/perplexityDecider.js

@@ -3,6 +3,7 @@ import { sniffImageMimeType } from "../utils/imageDetection.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlForError } from "../utils/logSanitize.js";
 import { getProviderModel } from "../utils/providerConfig.js";
+import { cleartextBaseURLProblem } from "./decide/baseUrl.js";
 import { isRecord, redactCredentials, SystemOneDecisionProvider, } from "./systemOneDecision.js";
 const PERPLEXITY_DEFAULT_BASE_URL = "https://api.perplexity.ai";
 const PERPLEXITY_ROUTE = "/v1/decisions";
@@ -50,6 +51,10 @@ function baseURLProblem(baseURL) {
         if (url.protocol !== "https:" && url.protocol !== "http:") {
             return `The Perplexity base URL must start with https:// or http://. ${fix}`;
         }
+        const cleartext = cleartextBaseURLProblem(url, "Perplexity", fix);
+        if (cleartext) {
+            return cleartext;
+        }
         return url.username || url.password || url.search || url.hash
             ? `The Perplexity base URL must not carry credentials, a query string or a fragment. ${fix}`
             : undefined;

package/dist/providers/systemOneDecision.js

@@ -56,6 +56,21 @@ export function redactCredentials(message, apiKey) {
         .replace(/data:[a-z]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "[media]")
         .trim();
 }
+/**
+ * Whether a failed `fetch` was one that refused a redirect. undici words every
+ * transport failure as `TypeError: fetch failed` and puts the reason on
+ * `cause`, so the chain is walked for its "unexpected redirect" text.
+ */
+function isRedirectRefusal(error) {
+    let current = error;
+    for (let depth = 0; depth < 5 && current instanceof Error; depth++) {
+        if (current.message === "unexpected redirect") {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+}
 /**
  * Rejects with the signal's reason when it aborts, so a caller tearing a turn
  * down is not held, nor its process kept alive, for the length of a vendor's
@@ -261,6 +276,9 @@ export class SystemOneDecisionProvider extends BaseProvider {
                     headers: this.decisionHeaders(),
                     body,
                     signal,
+                    // A 307 or 308 would replay the decision body at whatever address
+                    // the server names.
+                    redirect: "error",
                 });
                 const latencyMs = Date.now() - startedAt;
                 const requestId = this.readRequestId(response.headers);
@@ -351,12 +369,18 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 // turn is already being torn down.
                 const aborted = request.signal?.aborted === true;
                 const isTimeout = error instanceof Error && error.name === "TimeoutError";
+                const redirected = isRedirectRefusal(error);
                 lastError = {
                     kind: aborted ? "network" : isTimeout ? "timeout" : "network",
-                    message: redactCredentials(redactUrlsInText(error instanceof Error ? error.message : String(error)), this.decisionApiKey()),
-                    retryable: !aborted,
+                    // `fetch` words a refused redirect as "fetch failed", which says
+                    // nothing about why, and asking again meets the same answer. The
+                    // address it points at is the server's to choose, so it is not quoted.
+                    message: redirected
+                        ? `${label} answered with a redirect, which is refused so the decision is not sent anywhere else. Point the base URL at the final address.`
+                        : redactCredentials(redactUrlsInText(error instanceof Error ? error.message : String(error)), this.decisionApiKey()),
+                    retryable: !aborted && !redirected,
                 };
-                if (aborted || attempt === this.maxRetries) {
+                if (!lastError.retryable || attempt === this.maxRetries) {
                     throw this.decisionError(lastError);
                 }
                 await sleep(2 ** attempt * 250 + Math.random() * 250);

package/dist/types/guardrails.d.ts

@@ -50,6 +50,13 @@ export type PrecallEvaluationConfig = {
      * - Phone: '\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b'
      * - SSN: '\\b\\d{3}-\\d{2}-\\d{4}\\b'
      * - Custom words: '\\b(word1|word2|word3)\\b'
+     *
+     * A pattern is refused, skipped and logged as an error (never thrown at the
+     * caller) when it is longer than 1000 characters or has a shape that can
+     * backtrack catastrophically: a repeated group with a variable-length part
+     * that can also match what follows it, a repetition bound above 500, or
+     * overlapping alternatives under a repetition. See
+     * `BadWordsConfig.regexPatterns`.
      */
     sanitizationPatterns?: string[];
     /**
@@ -67,6 +74,37 @@ export type PrecallEvaluationConfig = {
 export type BadWordsConfig = {
     enabled?: boolean;
     list?: string[];
+    /**
+     * Regular expressions to redact, each applied with the `gi` flags. When set
+     * they take priority over `list`.
+     *
+     * Patterns run synchronously on the whole response, so a pattern that can
+     * backtrack catastrophically would stall the process. A pattern is refused,
+     * skipped and logged as an error (the same handling as an invalid regex,
+     * never thrown at the caller) when it:
+     *
+     * - is longer than 1000 characters;
+     * - repeats a group in which a variable-length part (`+`, `*`, `?`, `{n,m}`)
+     *   can match the same text as whatever follows it, so the input can be
+     *   split many ways: `(a+)+`, `(\w+\s*)*`, `(.*a){10}`, `(a?a?)+`,
+     *   `(a{1,30}){1,30}`;
+     * - repeats a group whose alternatives may overlap, such as `(a|aa)+`;
+     * - chains more than a handful of overlapping optional or open-ended parts,
+     *   such as `a?a?a?a?a?a?a?a?a?` or `.*a.*b.*c.*d.*e.*f`;
+     * - has a repetition bound above 500, such as `a{1,1000}`.
+     *
+     * A repeated group is fine when each variable-length part is followed by
+     * something it cannot match: `(\d{1,3}\.){3}`, `([a-z0-9-]+\.)+` and
+     * `(?:\d[ -]?){13,16}` all run.
+     *
+     * A skipped pattern filters nothing. Use `list` for plain terms, or flatten
+     * the pattern (`[\w-]+` instead of `([\w-]+)+`).
+     *
+     * Example patterns:
+     * - SSN: '\\d{3}-\\d{2}-\\d{4}'
+     * - Card number: '\\d{16}'
+     * - Words: '\\b(password|secret)\\b'
+     */
     regexPatterns?: string[];
     /**
      * Text to use when replacing filtered content.
@@ -109,8 +147,24 @@ export type ContentFilteringResult = {
     hasChanges: boolean;
     appliedFilters: string[];
     filteringStats: {
+        /** Regex patterns that were compiled and run. */
         regexPatternsApplied: number;
+        /**
+         * Regex patterns refused before they ran because they were too long or
+         * could backtrack catastrophically. Invalid patterns are not counted.
+         */
+        regexPatternsRejected?: number;
         stringFiltersApplied: number;
         totalMatches: number;
     };
 };
+/**
+ * Outcome of vetting a caller-supplied regular expression before it is
+ * compiled and run against model output.
+ */
+export type RegexPatternVerdict = {
+    safe: true;
+} | {
+    safe: false;
+    reason: string;
+};

package/dist/types/mcp.d.ts

@@ -1319,25 +1319,42 @@ export type RegistryConfig = {
      */
     type: RegistrySourceType;
     /**
-     * Registry URL or identifier
+     * Base URL of the registry. `official` defaults to
+     * `https://registry.modelcontextprotocol.io`; `custom` requires it. The
+     * client appends `/v0.1/servers`, so pass the origin (a trailing `/v0.1`
+     * is accepted too). Only `http:` and `https:` URLs without embedded
+     * credentials are used.
      */
     url?: string;
     /**
-     * Authentication token
+     * Bearer token sent as `Authorization: Bearer <token>` to this registry
+     * only. It is never emitted in events or logs. A registry with a token is
+     * queried only over `https:` or on a loopback host (`localhost`,
+     * `127.0.0.0/8`, `[::1]`); a plain `http:` URL to any other host is skipped
+     * so the token never crosses the network in clear.
      */
     authToken?: string;
     /**
-     * Request timeout in milliseconds
+     * Request timeout in milliseconds. Overrides the client-wide `timeout`
+     * for this registry.
      */
     timeout?: number;
     /**
-     * Enable caching
+     * Set to `false` to turn off caching of this registry's responses. It
+     * cannot override a client-wide `enableCache: false`, which turns caching
+     * off for every registry.
      */
     enableCache?: boolean;
     /**
-     * Cache TTL in milliseconds
+     * Cache TTL in milliseconds for this registry's responses. Falls back to
+     * the client-wide `defaultCacheTTL`.
      */
     cacheTTL?: number;
+    /**
+     * Maximum number of list pages (100 servers each) fetched when this
+     * registry is merged into `search()` / `getAllEntries()`. Defaults to 5.
+     */
+    maxPages?: number;
 };
 /**
  * Search options for registry queries
@@ -1395,11 +1412,24 @@ export type RegistrySearchResult = {
  */
 export type MCPRegistryClientConfig = {
     /**
-     * Default registries to use
+     * Registries to consult when `remoteLookup` is on. Only `official` and
+     * `custom` registries are queried; `npm` and `github` entries are accepted
+     * for compatibility but skipped. Defaults to the official MCP Registry.
      */
     registries?: RegistryConfig[];
     /**
-     * Enable automatic caching
+     * Opt in to remote lookups. Default `false`: the client then reads only
+     * its built-in catalog and custom entries and never touches the network,
+     * whatever `registries` says. When `true`, `getEntry()` falls back to the
+     * configured registries on a local miss and `search()` / `getAllEntries()`
+     * merge their servers after the local ones. Remote entries are always
+     * `verified: false`, and any network or parse failure falls back to the
+     * local result instead of throwing.
+     */
+    remoteLookup?: boolean;
+    /**
+     * Enable automatic caching. `false` turns it off for the merged list and
+     * for every registry, including one that sets its own `enableCache: true`.
      */
     enableCache?: boolean;
     /**
@@ -1407,14 +1437,80 @@ export type MCPRegistryClientConfig = {
      */
     defaultCacheTTL?: number;
     /**
-     * Request timeout
+     * Request timeout in milliseconds for each remote registry request
+     * (default 10000). A registry's own `timeout` takes precedence.
      */
     timeout?: number;
     /**
-     * User agent string
+     * User-Agent header sent on every remote registry request
      */
     userAgent?: string;
 };
+/**
+ * An input (environment variable or header) declared by a registry record.
+ * Mirrors the `KeyValueInput` schema of the official MCP Registry API.
+ */
+export type RemoteRegistryInput = {
+    name: string;
+    isRequired: boolean;
+    isSecret: boolean;
+};
+/**
+ * Transport declared by a registry record (`stdio`, `streamable-http` or
+ * `sse`). `url` is present for the remote transports.
+ */
+export type RemoteRegistryTransport = {
+    type: string;
+    url?: string;
+};
+/**
+ * A package a registry record can be installed from (`npm`, `pypi`, `oci`, ...)
+ */
+export type RemoteRegistryPackage = {
+    registryType: string;
+    identifier: string;
+    version?: string;
+    transport?: RemoteRegistryTransport;
+    environmentVariables: RemoteRegistryInput[];
+};
+/**
+ * Server description inside a registry record. Mirrors the `ServerDetail`
+ * schema of the official MCP Registry API, reduced to the fields the client
+ * reads; everything else in the response is ignored.
+ */
+export type RemoteRegistryServer = {
+    name: string;
+    description: string;
+    version: string;
+    repositoryUrl?: string;
+    websiteUrl?: string;
+    packages: RemoteRegistryPackage[];
+    remotes: RemoteRegistryTransport[];
+};
+/**
+ * One validated record from a remote registry: the server plus the status
+ * and timestamp the official registry reports under `_meta`.
+ */
+export type RemoteRegistryRecord = {
+    server: RemoteRegistryServer;
+    status?: string;
+    updatedAt?: string;
+};
+/**
+ * One validated page of a registry's server list
+ */
+export type RemoteRegistryPage = {
+    records: RemoteRegistryRecord[];
+    nextCursor?: string;
+};
+/**
+ * A registry the client can query: its configuration plus the resolved,
+ * credential-free API base URL (`.../v0.1`)
+ */
+export type RemoteRegistryTarget = {
+    config: RegistryConfig;
+    apiBase: string;
+};
 /**
  * Load balancing strategies
  */

package/dist/types/providerCatalog.d.ts

@@ -31,12 +31,13 @@ export type CatalogModelSpec = {
     /**
      * Per-model override of the provider-level `capabilities.tools`, for a
      * "model-dependent" provider whose vendor docs name which specific models
-     * accept tool definitions (e.g. Reka: "Currently, only Reka Flash
-     * supports function calling"). Absent means "inherit the provider-level
-     * answer", same as every model before this field existed. Only meaningful
-     * when `capabilities.tools` is `"model-dependent"` — a provider that
-     * already declares a plain `true`/`false` has no need for it, since that
-     * single value already applies to every model it serves.
+     * accept tool definitions (e.g. Reka: its Models table has a Tools column,
+     * Yes for reka-edge-2603 and No for reka-flash-3). Absent means "inherit
+     * the provider-level answer", same as every model before this field
+     * existed. Only meaningful when `capabilities.tools` is
+     * `"model-dependent"` — a provider that already declares a plain
+     * `true`/`false` has no need for it, since that single value already
+     * applies to every model it serves.
      */
     tools?: boolean;
     status: CatalogModelStatus;
@@ -263,7 +264,7 @@ export type ProviderCatalogJson = {
 };
 export type DecideFormatterName = "fastapi-validation";
 export type DecideBaseURLTransform = "strip-trailing-slash" | "strip-v1-suffix";
-/** A check a base URL must pass once normalised; `origin` allows only an http(s) URL with no userinfo, query string or fragment. */
+/** A check a base URL must pass once normalised; `origin` allows only an https URL (http only for localhost, 127.0.0.1 or [::1]) with no userinfo, query string or fragment. */
 export type DecideBaseURLShape = "origin";
 export type DecideErrorRule = {
     /** One status or a list of them. A rule sets this or `statusMin`, never both. */