@juspay/neurolink 13.0.3 → 13.1.1

package/dist/middleware/utils/regexSafety.js

@@ -0,0 +1,483 @@
+/**
+ * Static vetting for regular expressions that a caller hands to the
+ * guardrails (`badWords.regexPatterns`, `precallEvaluation.sanitizationPatterns`).
+ *
+ * Both lists are compiled and run synchronously on the event loop against the
+ * whole model response, so one pattern that backtracks catastrophically
+ * (`(a+)+$` on a run of `a`) stalls every request in the process. A timing
+ * probe on a short fixed string cannot find that: the cost only shows on long
+ * adversarial input, and it is measured after the call has already returned.
+ * This reads the pattern instead.
+ *
+ * The cause of every exponential case is one input that can be split between
+ * the parts of the pattern in many ways. A variable-length part (`a+`, `a?`,
+ * `a{1,3}`, `(ab)*`) is ambiguous when what can follow it may start with text
+ * the part itself can match. The check refuses a pattern when:
+ *
+ * - such a part sits inside a repeated group (`(a+)+`, `(a?a?)+`,
+ *   `(a{1,30}){1,30}`), where the ways multiply on every iteration;
+ * - the alternatives of a repeated group may overlap (`(a|aa)+`);
+ * - ambiguous parts are chained: more than {@link MAX_NARROW_WAYS} ways in
+ *   total from optional or short parts (`a?` nine times in a row), or more
+ *   than {@link MAX_OPEN_AMBIGUITY} open-ended ones (`.*a.*b.*c.*d.*e`);
+ * - a repetition bound is above {@link MAX_REPETITION_BOUND}, or the pattern
+ *   is longer than {@link MAX_REGEX_PATTERN_LENGTH}.
+ *
+ * A variable-length part that is followed by something it cannot match is
+ * unambiguous, so `(\d{1,3}\.){3}`, `([a-z0-9-]+\.)+` and `(?:\d[ -]?){13,16}`
+ * run.
+ *
+ * It is deliberately conservative, not a proof. Two classes are compared on a
+ * fixed sample of characters (Latin text plus a few other scripts), so a class
+ * that only overlaps outside the sample looks disjoint, and a back-reference
+ * is assumed to overlap with everything. A hard guarantee would need a time
+ * budget around the match itself (a `node:vm` timeout or a worker), which a
+ * synchronous `String.replace` cannot offer; that is a follow-up.
+ */
+/** Longest pattern accepted, in characters. */
+export const MAX_REGEX_PATTERN_LENGTH = 1000;
+/** Largest number accepted in a `{n}`, `{n,}` or `{n,m}` bound. */
+const MAX_REPETITION_BOUND = 500;
+/**
+ * A group repeated up to this many times has a bounded cost even when its
+ * alternatives overlap; above it the repetition counts as open-ended.
+ */
+const MAX_AMBIGUOUS_REPETITIONS = 8;
+/**
+ * A part whose length varies by at most this much (`a?`, `a{1,3}`) multiplies
+ * the ways to match by its range plus one. A wider one (`a*`, `a{2,50}`) adds
+ * a polynomial degree instead.
+ */
+const MAX_NARROW_RANGE = 8;
+/** Most ways the chained narrow ambiguous parts of a pattern may multiply to. */
+const MAX_NARROW_WAYS = 256;
+/** Most open-ended ambiguous parts a pattern may chain (`.*a.*b.*c.*d`). */
+const MAX_OPEN_AMBIGUITY = 4;
+const BRACE_QUANTIFIER = /^\{(\d+)(?:(,)(\d*))?\}/;
+const SHORTHAND_CLASSES = "dDwWsS";
+const ASSERTION_ESCAPES = "bB";
+const REASON_LOOP = "a repeated group has a variable-length part that can match the same text as what follows it, so the input can be split many ways (such as (a+)+ or (a?a?)+)";
+const REASON_ALTERNATIVES = "a repeated group has alternatives that may overlap (such as (a|aa)+)";
+const REASON_NARROW_CHAIN = `a chain of optional or short variable-length parts that may overlap can be matched in more than ${MAX_NARROW_WAYS} ways (such as a?a?a?a?a?a?a?a?a?)`;
+const REASON_OPEN_CHAIN = `more than ${MAX_OPEN_AMBIGUITY} open-ended repeats may match the same text (such as .*a.*b.*c.*d.*e)`;
+const REASON_BOUND = `a repetition bound is above ${MAX_REPETITION_BOUND}`;
+const parsePattern = (pattern) => {
+    let pos = 0;
+    /** Skips what follows `(` and reports whether the group is a lookaround. */
+    const skipGroupPrefix = () => {
+        if (pattern[pos] !== "?") {
+            return false;
+        }
+        const lookbehind = /^\?<[=!]/.test(pattern.slice(pos, pos + 3));
+        if (lookbehind) {
+            pos += 3;
+            return true;
+        }
+        if (pattern[pos + 1] === "<") {
+            const close = pattern.indexOf(">", pos);
+            pos = close === -1 ? pattern.length : close + 1;
+            return false;
+        }
+        const lookahead = pattern[pos + 1] === "=" || pattern[pos + 1] === "!";
+        pos += 2;
+        return lookahead;
+    };
+    const readClass = () => {
+        const start = pos - 1;
+        while (pos < pattern.length && pattern[pos] !== "]") {
+            pos += pattern[pos] === "\\" ? 2 : 1;
+        }
+        pos = Math.min(pos + 1, pattern.length);
+        return { kind: "class", source: pattern.slice(start, pos) };
+    };
+    /** Reads a fixed number of hex digits after `\x` or `\u`, if they are there. */
+    const readHexEscape = (digits) => {
+        const hex = pattern.slice(pos, pos + digits);
+        if (hex.length !== digits || !/^[0-9a-fA-F]+$/.test(hex)) {
+            return undefined;
+        }
+        pos += digits;
+        return String.fromCharCode(Number.parseInt(hex, 16));
+    };
+    const readEscape = () => {
+        const escaped = pattern[pos];
+        if (escaped === undefined) {
+            return { kind: "literal", char: "\\" };
+        }
+        pos += 1;
+        if (ASSERTION_ESCAPES.includes(escaped)) {
+            return { kind: "assertion" };
+        }
+        // `\x61` and `a` are the letter `a`: reading them as a class named
+        // `x` or `u` would hide `(\x61+)+` from every check below.
+        const hexChar = escaped === "x"
+            ? readHexEscape(2)
+            : escaped === "u"
+                ? readHexEscape(4)
+                : undefined;
+        if (hexChar !== undefined) {
+            return { kind: "literal", char: hexChar.toLowerCase() };
+        }
+        if (escaped === "c" && /[A-Za-z]/.test(pattern[pos] ?? "")) {
+            const control = String.fromCharCode(pattern.charCodeAt(pos) % 32);
+            pos += 1;
+            return { kind: "literal", char: control };
+        }
+        if (escaped === "0") {
+            return { kind: "literal", char: "\0" };
+        }
+        if (SHORTHAND_CLASSES.includes(escaped) || /[1-9A-Za-z]/.test(escaped)) {
+            return { kind: "class", source: `\\${escaped}` };
+        }
+        return { kind: "literal", char: escaped.toLowerCase() };
+    };
+    const readQuantifier = () => {
+        const ch = pattern[pos];
+        let quantifier;
+        if (ch === "*") {
+            quantifier = { min: 0, max: Infinity };
+            pos += 1;
+        }
+        else if (ch === "+") {
+            quantifier = { min: 1, max: Infinity };
+            pos += 1;
+        }
+        else if (ch === "?") {
+            quantifier = { min: 0, max: 1 };
+            pos += 1;
+        }
+        else if (ch === "{") {
+            const braces = BRACE_QUANTIFIER.exec(pattern.slice(pos));
+            if (braces) {
+                const min = Number(braces[1]);
+                let max = min;
+                if (braces[2] !== undefined) {
+                    max = braces[3] === "" ? Infinity : Number(braces[3]);
+                }
+                quantifier = { min, max };
+                pos += braces[0].length;
+            }
+        }
+        if (quantifier && pattern[pos] === "?") {
+            pos += 1;
+        }
+        return quantifier;
+    };
+    const parseAlternatives = (depth) => {
+        const alternatives = [];
+        let sequence = [];
+        while (pos < pattern.length) {
+            const ch = pattern[pos];
+            if (ch === ")" && depth > 0) {
+                break;
+            }
+            if (ch === "|") {
+                pos += 1;
+                alternatives.push(sequence);
+                sequence = [];
+                continue;
+            }
+            const quantifier = sequence.length > 0 ? readQuantifier() : undefined;
+            if (quantifier) {
+                const child = sequence[sequence.length - 1];
+                sequence = [
+                    ...sequence.slice(0, -1),
+                    { kind: "repeat", child, ...quantifier },
+                ];
+                continue;
+            }
+            pos += 1;
+            if (ch === "(") {
+                const lookaround = skipGroupPrefix();
+                const groupAlternatives = parseAlternatives(depth + 1);
+                if (pattern[pos] === ")") {
+                    pos += 1;
+                }
+                sequence.push({
+                    kind: "group",
+                    alternatives: groupAlternatives,
+                    ...(lookaround ? { lookaround } : {}),
+                });
+            }
+            else if (ch === "[") {
+                sequence.push(readClass());
+            }
+            else if (ch === "\\") {
+                sequence.push(readEscape());
+            }
+            else if (ch === ".") {
+                sequence.push({ kind: "class", source: "." });
+            }
+            else if (ch === "^" || ch === "$") {
+                sequence.push({ kind: "assertion" });
+            }
+            else {
+                sequence.push({ kind: "literal", char: ch.toLowerCase() });
+            }
+        }
+        alternatives.push(sequence);
+        return alternatives;
+    };
+    return parseAlternatives(0);
+};
+// ---------------------------------------------------------------------------
+// Character sets
+//
+// Two classes are compared on a fixed sample of characters rather than by
+// parsing them: the engine itself decides what `[\w-]` or `\S` matches. A set
+// is a bitmap over the sample, so "can these two match the same character" is
+// a word-wise AND.
+// ---------------------------------------------------------------------------
+const EXTRA_SAMPLE_CODES = [
+    0x3b1, 0x410, 0x5d0, 0x627, 0x4e2d, 0xac00, 0x2028, 0x2029, 0xfeff, 0xffff,
+];
+const SAMPLE_CHARS = [
+    ...Array.from({ length: 0x300 }, (_, code) => String.fromCharCode(code)),
+    ...EXTRA_SAMPLE_CODES.map((code) => String.fromCharCode(code)),
+];
+const SET_WORDS = Math.ceil(SAMPLE_CHARS.length / 32);
+const EMPTY_SET = new Uint32Array(SET_WORDS);
+const FULL_SET = new Uint32Array(SET_WORDS).fill(0xffffffff);
+const setOf = (matches) => {
+    const set = new Uint32Array(SET_WORDS);
+    SAMPLE_CHARS.forEach((char, index) => {
+        if (matches(char)) {
+            set[index >>> 5] |= 1 << (index & 31);
+        }
+    });
+    return set;
+};
+const unionOf = (left, right) => left.map((word, index) => word | right[index]);
+const overlaps = (left, right) => left.some((word, index) => (word & right[index]) !== 0);
+/**
+ * The characters a class matches. A back-reference or a class that does not
+ * compile cannot be compared, so it is assumed to match everything.
+ */
+const classSetOf = (source) => {
+    if (/^\\[1-9k]/.test(source)) {
+        return FULL_SET;
+    }
+    try {
+        const matcher = new RegExp(`^(?:${source})$`, "i");
+        return setOf((char) => matcher.test(char));
+    }
+    catch {
+        return FULL_SET;
+    }
+};
+// ---------------------------------------------------------------------------
+// Ambiguity analysis
+// ---------------------------------------------------------------------------
+const NO_COST = { ways: 1, degree: 0 };
+const TOP_LEVEL = { inLoop: false, unbounded: false };
+const chain = (left, right) => ({
+    ways: left.ways * right.ways,
+    degree: left.degree + right.degree,
+});
+const worse = (left, right) => ({
+    ways: Math.max(left.ways, right.ways),
+    degree: Math.max(left.degree, right.degree),
+});
+const literalWord = (sequence) => {
+    const chars = sequence.map((node) => node.kind === "literal" ? node.char : undefined);
+    return chars.every((char) => char !== undefined) ? chars.join("") : undefined;
+};
+/** True when no word is a prefix of another, so the words decode uniquely. */
+const isPrefixFree = (words) => {
+    const sorted = [...words].sort();
+    return sorted.every((word, index) => index === 0 || !word.startsWith(sorted[index - 1]));
+};
+const analyze = (alternatives) => {
+    const shapes = new WeakMap();
+    const shapeOfSequence = (sequence) => {
+        let first = EMPTY_SET;
+        let nullable = true;
+        for (const node of sequence) {
+            if (!nullable) {
+                break;
+            }
+            const shape = shapeOf(node);
+            first = unionOf(first, shape.first);
+            nullable = shape.nullable;
+        }
+        return { first, nullable };
+    };
+    const shapeOf = (node) => {
+        const known = shapes.get(node);
+        if (known) {
+            return known;
+        }
+        let shape;
+        switch (node.kind) {
+            case "literal":
+                shape = {
+                    first: setOf((char) => char.toLowerCase() === node.char),
+                    nullable: false,
+                };
+                break;
+            case "class":
+                shape = { first: classSetOf(node.source), nullable: false };
+                break;
+            case "assertion":
+                shape = { first: EMPTY_SET, nullable: true };
+                break;
+            case "group": {
+                if (node.lookaround) {
+                    shape = { first: EMPTY_SET, nullable: true };
+                    break;
+                }
+                const parts = node.alternatives.map(shapeOfSequence);
+                shape = {
+                    first: parts.reduce((all, part) => unionOf(all, part.first), EMPTY_SET),
+                    nullable: parts.some((part) => part.nullable),
+                };
+                break;
+            }
+            case "repeat": {
+                const child = shapeOf(node.child);
+                shape = {
+                    first: child.first,
+                    nullable: node.min === 0 || child.nullable,
+                };
+                break;
+            }
+        }
+        shapes.set(node, shape);
+        return shape;
+    };
+    /** True when two alternatives of a group could match the same text. */
+    const alternativesOverlap = (group) => {
+        const words = group.map(literalWord);
+        if (words.every((word) => word !== undefined)) {
+            return !isPrefixFree(words);
+        }
+        const parts = group.map(shapeOfSequence);
+        return parts.some((part, index) => part.nullable ||
+            parts
+                .slice(index + 1)
+                .some((other) => overlaps(part.first, other.first)));
+    };
+    const analyzeSequence = (sequence, after, context) => {
+        let total = NO_COST;
+        let follow = after;
+        for (let index = sequence.length - 1; index >= 0; index -= 1) {
+            const node = sequence[index];
+            const outcome = analyzeNode(node, follow, context);
+            if (typeof outcome === "string") {
+                return outcome;
+            }
+            total = chain(total, outcome);
+            const shape = shapeOf(node);
+            follow = shape.nullable ? unionOf(shape.first, follow) : shape.first;
+        }
+        return total;
+    };
+    const analyzeAlternatives = (group, after, context) => {
+        let worst = NO_COST;
+        for (const sequence of group) {
+            const outcome = analyzeSequence(sequence, after, context);
+            if (typeof outcome === "string") {
+                return outcome;
+            }
+            worst = worse(worst, outcome);
+        }
+        return worst;
+    };
+    const analyzeNode = (node, after, context) => {
+        if (node.kind === "group") {
+            if (node.lookaround) {
+                return analyzeAlternatives(node.alternatives, EMPTY_SET, TOP_LEVEL);
+            }
+            const overlapping = node.alternatives.length > 1 && alternativesOverlap(node.alternatives);
+            if (overlapping && context.unbounded) {
+                return REASON_ALTERNATIVES;
+            }
+            const inner = analyzeAlternatives(node.alternatives, after, context);
+            if (typeof inner === "string") {
+                return inner;
+            }
+            return overlapping ? chain(inner, { ways: 2, degree: 0 }) : inner;
+        }
+        if (node.kind !== "repeat") {
+            return NO_COST;
+        }
+        const finiteMax = Number.isFinite(node.max) ? node.max : 0;
+        if (node.min > MAX_REPETITION_BOUND || finiteMax > MAX_REPETITION_BOUND) {
+            return REASON_BOUND;
+        }
+        const child = shapeOf(node.child);
+        const variable = node.min < node.max;
+        const ambiguous = variable && overlaps(child.first, after);
+        if (ambiguous && context.inLoop) {
+            return REASON_LOOP;
+        }
+        const repeatsGroup = node.max > 1 &&
+            node.child.kind !== "literal" &&
+            node.child.kind !== "class";
+        let inner;
+        if (repeatsGroup) {
+            // The next iteration starts where this one ends, so its first
+            // characters follow every part of the body.
+            inner = analyzeNode(node.child, unionOf(child.first, after), {
+                inLoop: true,
+                unbounded: context.unbounded || node.max > MAX_AMBIGUOUS_REPETITIONS,
+            });
+        }
+        else {
+            inner = analyzeNode(node.child, after, context);
+        }
+        if (typeof inner === "string") {
+            return inner;
+        }
+        const looped = repeatsGroup
+            ? {
+                ways: inner.ways ** (Number.isFinite(node.max) ? node.max : 1),
+                degree: inner.degree,
+            }
+            : inner;
+        if (!ambiguous) {
+            return looped;
+        }
+        const range = node.max - node.min;
+        return chain(looped, range <= MAX_NARROW_RANGE
+            ? { ways: range + 1, degree: 0 }
+            : { ways: 1, degree: 1 });
+    };
+    const outcome = analyzeAlternatives(alternatives, EMPTY_SET, TOP_LEVEL);
+    if (typeof outcome === "string") {
+        return outcome;
+    }
+    if (outcome.ways > MAX_NARROW_WAYS) {
+        return REASON_NARROW_CHAIN;
+    }
+    if (outcome.degree > MAX_OPEN_AMBIGUITY) {
+        return REASON_OPEN_CHAIN;
+    }
+    return outcome;
+};
+/**
+ * Decide whether a caller-supplied pattern may be compiled and run.
+ *
+ * Total: it returns a verdict for any string and never throws, so a caller can
+ * skip a refused pattern the same way it skips an invalid one.
+ */
+export function vetRegexPattern(pattern) {
+    if (pattern.length > MAX_REGEX_PATTERN_LENGTH) {
+        return {
+            safe: false,
+            reason: `the pattern is ${pattern.length} characters long and the limit is ${MAX_REGEX_PATTERN_LENGTH}`,
+        };
+    }
+    try {
+        const outcome = analyze(parsePattern(pattern));
+        return typeof outcome === "string"
+            ? { safe: false, reason: outcome }
+            : { safe: true };
+    }
+    catch {
+        return {
+            safe: false,
+            reason: "the pattern is too deeply nested to analyse",
+        };
+    }
+}

package/dist/neurolink.d.ts

@@ -1845,6 +1845,10 @@ export declare class NeuroLink {
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics
+     *
+     * Bedrock and SageMaker are never called live: their entries come back as
+     * `status: "not-configured"` with `configured: true` and the reason in
+     * `error`. Use `testProvider()` to check either one explicitly.
      */
     getProviderStatus(options?: {
         quiet?: boolean;

package/dist/neurolink.js

@@ -11870,6 +11870,10 @@ Current user's request: ${currentInput}`;
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics
+     *
+     * Bedrock and SageMaker are never called live: their entries come back as
+     * `status: "not-configured"` with `configured: true` and the reason in
+     * `error`. Use `testProvider()` to check either one explicitly.
      */
     async getProviderStatus(options) {
         // Track memory and timing for provider status checks
@@ -11912,6 +11916,19 @@ Current user's request: ${currentInput}`;
                         responseTime: Date.now() - startTime,
                     };
                 }
+                // These probes are billable generate() calls signed with ambient AWS
+                // credentials, against models the account may not be allowed to
+                // call, so they are never made here.
+                if (providerName === "bedrock" || providerName === "sagemaker") {
+                    return {
+                        provider: providerName,
+                        status: "not-configured",
+                        configured: true,
+                        authenticated: false,
+                        error: `Live status check is skipped for ${providerName}`,
+                        responseTime: Date.now() - startTime,
+                    };
+                }
                 // Special handling for Ollama
                 if (providerName === "ollama") {
                     let ollamaAttempt;

package/dist/providers/catalog/provider-catalog.schema.json

@@ -122,7 +122,7 @@
         },
         "baseURLShape": {
           "enum": ["origin"],
-          "description": "Refuses a normalised base URL that is not an http(s) URL without userinfo, a query string or a fragment. Omitted means no check."
+          "description": "Refuses a normalised base URL that is not an https URL (http is allowed only for localhost, 127.0.0.1 and [::1]) without userinfo, a query string or a fragment. Omitted means no check."
         },
         "endpoint": {
           "type": "string",

package/dist/providers/catalog/reka.json

@@ -21,7 +21,7 @@
                 "vision": true,
                 "tools": true,
                 "status": "production",
-                "description": "NeuroLink default. Listed as reka-flash in the baseline model table on https://docs.reka.ai/chat/models.md (intro: \"Our baseline models always available for public access are:\") and named as the model in the code examples on https://docs.reka.ai/chat/overview.md, https://docs.reka.ai/chat/function-calling.md and https://docs.reka.ai/chat/api-reference/create.md (retrieved 2026-09-29). https://docs.reka.ai/pricing.md has a row named \"Reka Flash\" described as \"Fast and cost-efficient model for most tasks\" with $0.80 under \"Input Tokens (per 1M)\" and $2.00 under \"Output Tokens (per 1M)\"; https://docs.reka.ai/chat/models.md ends with \"For full listing of models and pricing, see the Reka API Pricing page\". https://docs.reka.ai/chat/function-calling.md says \"Currently, only Reka Flash supports function calling.\" Vision is true: the first curl example on https://docs.reka.ai/overview.md sends an image_url content part to model \"reka-flash\", and the Quickstart's \"First request\" example (https://docs.reka.ai/quickstart.md) carries the comment '# or \"reka-flash\"' beside an image_url request. No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
+                "description": "NeuroLink default. Listed as reka-flash in the baseline model table on https://docs.reka.ai/chat/models.md (intro: \"Our baseline models always available for public access are:\") and named as the model in the code examples on https://docs.reka.ai/chat/overview.md, https://docs.reka.ai/chat/function-calling.md and https://docs.reka.ai/chat/api-reference/create.md (retrieved 2026-09-29). https://docs.reka.ai/pricing.md has a row named \"Reka Flash\" described as \"Fast and cost-efficient model for most tasks\" with $0.80 under \"Input Tokens (per 1M)\" and $2.00 under \"Output Tokens (per 1M)\"; https://docs.reka.ai/chat/models.md ends with \"For full listing of models and pricing, see the Reka API Pricing page\". tools is true because https://docs.reka.ai/chat/function-calling.md said \"Currently, only Reka Flash supports function calling.\" on 2026-09-29. That sentence is gone: on 2026-10-17 https://docs.reka.ai/chat/function-calling.md redirects to https://docs.reka.ai/chat/overview.md, and neither it nor the Models table at https://docs.reka.ai/chat/models.md uses the id reka-flash (they name reka-flash-3), so this flag and this entry are not confirmed against the current docs and are kept as they were pending a check with a key. Vision is true: the first curl example on https://docs.reka.ai/overview.md sends an image_url content part to model \"reka-flash\", and the Quickstart's \"First request\" example (https://docs.reka.ai/quickstart.md) carries the comment '# or \"reka-flash\"' beside an image_url request. No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
             },
             "reka-edge": {
                 "pricingPerMTok": {
@@ -29,9 +29,9 @@
                     "output": 0.1
                 },
                 "vision": true,
-                "tools": false,
+                "tools": true,
                 "status": "production",
-                "description": "Listed as \"reka-edge (or reka-edge-2603)\" in the baseline model table on https://docs.reka.ai/chat/models.md and on https://docs.reka.ai/quickstart.md (retrieved 2026-09-29). The Quickstart's \"First request\" example sends an image_url content part to model \"reka-edge\", and the example response on https://docs.reka.ai/chat/api-reference/get.md lists the id \"reka-edge\". https://docs.reka.ai/pricing.md has a row named \"Reka Edge\" described as \"Compact model ideal for on-device execution\" with $0.10 under \"Input Tokens (per 1M)\" and $0.10 under \"Output Tokens (per 1M)\". https://docs.reka.ai/chat/function-calling.md says \"Currently, only Reka Flash supports function calling.\" No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
+                "description": "Listed as \"reka-edge (or reka-edge-2603)\" in the baseline model table on https://docs.reka.ai/chat/models.md and on https://docs.reka.ai/quickstart.md (retrieved 2026-09-29). The Quickstart's \"First request\" example sends an image_url content part to model \"reka-edge\", and the example response on https://docs.reka.ai/chat/api-reference/get.md lists the id \"reka-edge\". https://docs.reka.ai/pricing.md has a row named \"Reka Edge\" described as \"Compact model ideal for on-device execution\" with $0.10 under \"Input Tokens (per 1M)\" and $0.10 under \"Output Tokens (per 1M)\". tools is true because reka-edge is the alias of reka-edge-2603, which the current docs mark as tool-capable (see the reka-edge-2603 entry); it was false while https://docs.reka.ai/chat/function-calling.md said \"Currently, only Reka Flash supports function calling.\" (retrieved 2026-09-29), a sentence that no longer appears. The Models table at https://docs.reka.ai/chat/models.md (retrieved 2026-10-17) has no row named reka-edge, only reka-edge-2603, so whether the API still serves the bare alias is not confirmed. No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
             },
             "reka-edge-2603": {
                 "pricingPerMTok": {
@@ -39,9 +39,19 @@
                     "output": 0.1
                 },
                 "vision": true,
+                "tools": true,
+                "status": "production",
+                "description": "Tools are supported per Reka's current docs (retrieved 2026-10-17). The Models table at https://docs.reka.ai/chat/models.md has the header | Model ID | Context | Input | Tools | Structured outputs | Reasoning | and the row | `reka-edge-2603` | 16k | Text, image, video | Yes | Yes | No |, so the Tools column is Yes. The GET /v1/models example on the same page shows \"supported_features\": [\"tools\", \"structured_outputs\", \"streaming\"] for reka-edge-2603, and the page says \"`GET /v1/models` is the authoritative list\". The Tools section of https://docs.reka.ai/chat/overview.md (https://docs.reka.ai/chat/function-calling.md redirects there) says \"Models that list `tools` in their `supported_features` accept OpenAI-format `tools` and `tool_choice`.\" and its example request calls model=\"reka-edge-2603\" with a tools list. This replaces tools: false, which rested on the sentence \"Currently, only Reka Flash supports function calling.\" on https://docs.reka.ai/chat/function-calling.md (retrieved 2026-09-29); that sentence no longer appears. Not wire-verified: no API key was used. Vision is true because the Models table lists \"Text, image, video\" as the input. Prices are those of the \"Reka Edge\" row of https://docs.reka.ai/pricing.md (retrieved 2026-09-29) and match the GET /v1/models example's \"prompt\": \"0.0000001\" and \"completion\": \"0.0000001\" US dollars per token. Earlier evidence (retrieved 2026-09-29): named in the same table row as reka-edge, \"reka-edge (or reka-edge-2603)\", on https://docs.reka.ai/chat/models.md and https://docs.reka.ai/quickstart.md. No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
+            },
+            "reka-flash-3": {
+                "pricingPerMTok": {
+                    "input": 0.1,
+                    "output": 0.2
+                },
+                "vision": false,
                 "tools": false,
                 "status": "production",
-                "description": "Named in the same table row as reka-edge, \"reka-edge (or reka-edge-2603)\", on https://docs.reka.ai/chat/models.md and https://docs.reka.ai/quickstart.md, and shown as {\"id\": \"reka-edge-2603\"} in the example output of GET https://api.reka.ai/v1/models on https://docs.reka.ai/chat/models.md, which says \"All of these model IDs can be used as values for the Chat API's model parameter\" (retrieved 2026-09-29). Vision and prices are those of the row's reka-edge example and its \"Reka Edge\" pricing row (https://docs.reka.ai/quickstart.md, https://docs.reka.ai/pricing.md). No context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply."
+                "description": "Listed in the Models table at https://docs.reka.ai/chat/models.md (retrieved 2026-10-17) with the row | `reka-flash-3` | 64k | Text | No | Yes | Yes |, so input is text only (vision is false) and the Tools column is No (tools is false), the entry that keeps the per-model withhold path covered. Prices are the \"$0.10/M input tokens\" and \"$0.20/M output tokens\" shown on its card at https://developer.reka.ai/models (retrieved 2026-10-17), which the Models page names as the source of current prices. The Models page says 64k for the context, a rounded figure, so no context window or maximum output figure is set for this model; models.defaultContextWindow and models.defaultMaxOutputTokens apply. This is a different model from the reka-flash entry above, whose id no longer appears in the current Models table."
             }
         },
         "topModels": ["reka-flash", "reka-edge", "reka-edge-2603"]
@@ -91,7 +101,7 @@
             "3. Authentication: the vendor's REST examples send the header X-Api-Key (https://docs.reka.ai/chat/overview.md) and the OpenAPI file https://docs.reka.ai/openapi/api-reference.yaml declares one security scheme, an apiKey in the header X-Api-Key; the OpenAI Python SDK examples pass api_key=\"YOUR_API_KEY\" to the client (https://docs.reka.ai/quickstart.md)",
             "4. Set {apiKeyEnvVar} in your .env file"
         ],
-        "description": "Docs-verified only: the vendor's GET https://api.reka.ai/v1/models needs a key (it answers HTTP 401 without one), so the three model ids come from https://docs.reka.ai/chat/models.md and the roster has not been checked; the entry is not yet live-verified. Endpoint https://api.reka.ai/v1: the Quickstart (https://docs.reka.ai/quickstart.md) says \"our API is fully OpenAI-compatible\" and shows the OpenAI Python SDK with base_url \"https://api.reka.ai/v1\"; https://docs.reka.ai/chat/overview.md shows POST https://api.reka.ai/v1/chat/completions with a messages array and reads the reply from response.choices[0].message.content. Unauthenticated GETs made 2026-09-29: /models answered HTTP 401 with the JSON body {\"error\":{\"message\":\"Unauthorized\",\"type\":\"authentication_error\",\"code\":null,\"param\":null}}; /chat/completions answered HTTP 405 with header allow: POST and the body {\"detail\":\"Method Not Allowed\"}. No POST request was sent. errorRules carry the statuses https://docs.reka.ai/errors.md lists (401 authentication_error, 429 rate_limit_error, 500 server_error) plus a pattern rule on the FAQ's \"P001: Insufficient Balance\" text. capabilities.streaming is true because https://docs.reka.ai/chat/overview.md says \"The Chat API supports streaming\". capabilities.tools is model-dependent because https://docs.reka.ai/chat/function-calling.md documents the tools parameter and tool_calls and says \"Currently, only Reka Flash supports function calling.\" That sentence is why reka-flash's models.catalog entry sets tools: true and reka-edge/reka-edge-2603 set tools: false (see CatalogModelSpec.tools) instead of leaving every model to the provider-level model-dependent default. capabilities.structuredOutput is false: the ChatRequest on https://docs.reka.ai/chat/api-reference/create.md lists messages, model, frequency_penalty, max_tokens, presence_penalty, seed, stop, stream, temperature, tool_choice, tools, top_k and top_p. capabilities.toolsWithStreaming and capabilities.structuredOutputWithTools are false because no request combining them was sent. capabilities.embeddings and capabilities.thinking are false. models.defaultContextWindow (16384) and models.defaultMaxOutputTokens (4096) are placeholders the vendor does not publish; the Chat API reference describes max_tokens as \"limited by the model's context length. Defaults to 1024.\" Each model's status field holds production, a placeholder for a value the catalog schema requires; it is not a vendor statement. billingPolicy holds free-tier, one of the three values the catalog schema allows (free-tier, free-with-card, no-free-tier). The vendor wording behind it: on https://platform.reka.ai/pricing the Pay as you go tile has a \"Start for free\" link to /sign-up and the page carries the text \"Free credits used\"; https://docs.reka.ai/pricing.md says \"Get started with no upfront costs.\"; https://docs.reka.ai/resources/faqs.md answers \"Do I need to pre-pay?\" with \"Yes. Add credits to your account before making requests.\" apiKeyFormat is null, so NeuroLink's key-format check is not applied."
+        "description": "Docs-verified only: the vendor's GET https://api.reka.ai/v1/models needs a key (it answers HTTP 401 without one), so the four model ids come from https://docs.reka.ai/chat/models.md (retrieved 2026-09-29 for the first three and 2026-10-17 for reka-flash-3) and the roster has not been checked; the entry is not yet live-verified. Endpoint https://api.reka.ai/v1: the Quickstart (https://docs.reka.ai/quickstart.md) says \"our API is fully OpenAI-compatible\" and shows the OpenAI Python SDK with base_url \"https://api.reka.ai/v1\"; https://docs.reka.ai/chat/overview.md shows POST https://api.reka.ai/v1/chat/completions with a messages array and reads the reply from response.choices[0].message.content. Unauthenticated GETs made 2026-09-29: /models answered HTTP 401 with the JSON body {\"error\":{\"message\":\"Unauthorized\",\"type\":\"authentication_error\",\"code\":null,\"param\":null}}; /chat/completions answered HTTP 405 with header allow: POST and the body {\"detail\":\"Method Not Allowed\"}. No POST request was sent. errorRules carry the statuses https://docs.reka.ai/errors.md lists (401 authentication_error, 429 rate_limit_error, 500 server_error) plus a pattern rule on the FAQ's \"P001: Insufficient Balance\" text. capabilities.streaming is true because https://docs.reka.ai/chat/overview.md says \"The Chat API supports streaming\". capabilities.tools is model-dependent because tool support differs per model: the Models table at https://docs.reka.ai/chat/models.md (retrieved 2026-10-17) has a \"Tools\" column that is Yes for reka-edge-2603 and No for reka-flash-3, and the Tools section of https://docs.reka.ai/chat/overview.md says \"Models that list `tools` in their `supported_features` accept OpenAI-format `tools` and `tool_choice`.\" So the models.catalog entries set tools: true for reka-edge-2603 and its alias reka-edge, and tools: false for reka-flash-3 (see CatalogModelSpec.tools), instead of leaving every model to the provider-level model-dependent default. reka-flash keeps tools: true from the sentence \"Currently, only Reka Flash supports function calling.\" (retrieved 2026-09-29), which the current pages no longer carry; that entry is unconfirmed. capabilities.structuredOutput is false: the ChatRequest on https://docs.reka.ai/chat/api-reference/create.md lists messages, model, frequency_penalty, max_tokens, presence_penalty, seed, stop, stream, temperature, tool_choice, tools, top_k and top_p. capabilities.toolsWithStreaming and capabilities.structuredOutputWithTools are false because no request combining them was sent. capabilities.embeddings and capabilities.thinking are false. models.defaultContextWindow (16384) and models.defaultMaxOutputTokens (4096) are placeholders the vendor does not publish; the Chat API reference describes max_tokens as \"limited by the model's context length. Defaults to 1024.\" Each model's status field holds production, a placeholder for a value the catalog schema requires; it is not a vendor statement. billingPolicy holds free-tier, one of the three values the catalog schema allows (free-tier, free-with-card, no-free-tier). The vendor wording behind it: on https://platform.reka.ai/pricing the Pay as you go tile has a \"Start for free\" link to /sign-up and the page carries the text \"Free credits used\"; https://docs.reka.ai/pricing.md says \"Get started with no upfront costs.\"; https://docs.reka.ai/resources/faqs.md answers \"Do I need to pre-pay?\" with \"Yes. Add credits to your account before making requests.\" apiKeyFormat is null, so NeuroLink's key-format check is not applied."
     },
     "evidence": {
         "rosterVerified": {

package/dist/providers/cloudflareClef.js

@@ -2,6 +2,7 @@ import { CloudflareClefModels } from "../constants/enums.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 CLOUDFLARE_DEFAULT_BASE_URL = "https://api.cloudflare.com/client/v4";
 const MODEL_PREFIX = "@cf/cloudflare/";
@@ -61,6 +62,10 @@ function baseURLProblem(baseURL) {
         if (url.protocol !== "https:" && url.protocol !== "http:") {
             return `The Cloudflare base URL must start with https:// or http://. ${fix}`;
         }
+        const cleartext = cleartextBaseURLProblem(url, "Cloudflare", fix);
+        if (cleartext) {
+            return cleartext;
+        }
         // `url.search` and `url.hash` are empty for a bare trailing `?` or `#`, which
         // would still put the route into the query or the fragment, so the text is
         // checked as well.

package/dist/providers/decide/baseUrl.d.ts

@@ -1,4 +1,12 @@
 import type { DecideBaseURLShape, DecideBaseURLTransform } from "../../types/index.js";
 export declare function normalizeBaseURL(raw: string, transforms: readonly DecideBaseURLTransform[]): string;
+/** Whether a `URL.hostname` is this machine, so a plain-http request to it never leaves it. */
+export declare function isLoopbackHost(hostname: string): boolean;
+/**
+ * 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 declare function cleartextBaseURLProblem(url: URL, displayName: string, fix: string): string | undefined;
 /** Why a normalised base URL fails the shape, or undefined when it passes. */
 export declare function baseURLShapeProblem(shape: DecideBaseURLShape, baseURL: string, displayName: string, fix: string): string | undefined;