@juspay/neurolink 13.0.2 → 13.1.0

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/client.d.ts

@@ -443,16 +443,51 @@ export type ClientMiddlewareContext = {
     /** Additional context data */
     [key: string]: unknown;
 };
+/**
+ * What `type` holds on the element `NeuroLinkProvider` returns: React's context
+ * provider descriptor, an exotic component that carries a `$$typeof` tag and is
+ * not meant to be called.
+ *
+ * Spelled without importing React, for the reason given on `ClientReactElement`.
+ * The call signature never returns, so the descriptor cannot be called for a
+ * value, and `props` is `unknown` so it still fits React's `JSXElementConstructor`.
+ */
+export type ClientReactProviderDescriptor = ((props: unknown) => never) & {
+    readonly $$typeof: symbol;
+};
+/**
+ * What `NeuroLinkProvider` returns, spelled without importing React.
+ *
+ * The published declaration of the hooks module cannot name a React type: `react`
+ * is an optional peer, and a consumer without it fails to compile the whole
+ * `@juspay/neurolink/client` entry point (TS2307). This is the shape of React's
+ * element, so a value of this type is still a valid JSX component return and
+ * assignable to `ReactNode` and `ReactElement`.
+ *
+ * `type` is either a host-element tag (a string) or the provider's descriptor,
+ * which is what the element returned by `NeuroLinkProvider` carries at runtime.
+ * Narrow it before use (`typeof element.type === "string"`); a string method
+ * called on it directly is a compile error. Nothing should rely on it: it names
+ * React's internal representation, which React may change.
+ */
+export type ClientReactElement = {
+    type: string | ClientReactProviderDescriptor;
+    props: unknown;
+    key: string | null;
+};
 /**
  * Props for the NeuroLinkProvider React component.
  *
- * `children` is typed as `unknown` so this module stays React-agnostic;
- * the provider component in reactHooks.tsx narrows it to `ReactNode`.
+ * `children` is typed as `unknown` so the declaration needs no React types.
+ * Anything React accepts as a child is accepted, and so is anything else: the
+ * type does not check it. The component renders it as a React node, so a value
+ * React cannot render (a function, a plain object) compiles and then fails in
+ * React at render time.
  */
 export type NeuroLinkProviderProps = {
     /** Client configuration */
     config: ClientConfig;
-    /** Child components (ReactNode at runtime) */
+    /** Child components. Typed `unknown` and rendered as a React node without a type check. */
     children: unknown;
 };
 /**

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. */