@juspay/neurolink 12.46.0 → 12.47.0

package/dist/providers/systemOneDecision.js

@@ -6,7 +6,7 @@ import { ProviderError } from "../types/index.js";
 import { prepareDecisionMedia } from "../utils/decisionMedia.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlsInText } from "../utils/logSanitize.js";
-import { estimateTokens, serializeForEstimate, } from "../utils/tokenEstimation.js";
+import { CHARS_PER_TOKEN, estimateTokens, serializeForEstimate, } from "../utils/tokenEstimation.js";
 /**
  * Generous enough for a cold start (measured at 2.0–2.7s after idle on Jev)
  * while still bounded. Every internal caller is fail-open, so this only bites
@@ -177,15 +177,52 @@ const sleep = (ms, signal) => new Promise((resolve, reject) => {
  * tokenizer, so when a provider declares a rate, non-ASCII characters are
  * counted at it instead. ASCII text is estimated exactly as before.
  */
-function estimateDecisionStateTokens(text, nonAsciiTokensPerChar) {
-    if (nonAsciiTokensPerChar === undefined) {
+function estimateDecisionStateTokens(text, nonAsciiTokensPerChar, rates = {}) {
+    const { digit, symbol, astral } = rates;
+    if (nonAsciiTokensPerChar === undefined &&
+        digit === undefined &&
+        symbol === undefined &&
+        astral === undefined) {
         return estimateTokens(text);
     }
-    const chars = [...text];
-    const isAscii = (c) => (c.codePointAt(0) ?? 0) <= 0x7f;
-    const ascii = chars.filter(isAscii).join("");
-    const nonAsciiCount = chars.length - ascii.length;
-    return (estimateTokens(ascii) + Math.ceil(nonAsciiCount * nonAsciiTokensPerChar));
+    // Each class of character is counted once, at its own rate. A class with no
+    // declared rate stays in the ordinary four-characters-a-token estimate (or,
+    // for non-ASCII, at that estimate's per-character rate), so a provider that
+    // declares none of the extra rates is estimated exactly as before.
+    const isDigit = (c) => c >= "0" && c <= "9";
+    const isSymbol = (c) => /[!-/:-@[-`{-~]/.test(c);
+    let digits = 0;
+    let symbols = 0;
+    let astrals = 0;
+    let nonAscii = 0;
+    const rest = [];
+    for (const c of text) {
+        const code = c.codePointAt(0) ?? 0;
+        if (code > 0xffff && astral !== undefined) {
+            astrals += 1;
+        }
+        else if (code > 0x7f) {
+            nonAscii += 1;
+        }
+        else if (digit !== undefined && isDigit(c)) {
+            digits += 1;
+        }
+        else if (symbol !== undefined && isSymbol(c)) {
+            symbols += 1;
+        }
+        else {
+            rest.push(c);
+        }
+    }
+    // Digits, punctuation and astral characters (emoji) are charged separately
+    // only when the provider declares a rate for them: a tokenizer that reads each
+    // digit, and most punctuation, on its own makes a number-heavy or JSON-heavy
+    // state several times longer than four characters a token suggests.
+    return (estimateTokens(rest.join("")) +
+        Math.ceil(digits * (digit ?? 0)) +
+        Math.ceil(symbols * (symbol ?? 0)) +
+        Math.ceil(astrals * (astral ?? 0)) +
+        Math.ceil(nonAscii * (nonAsciiTokensPerChar ?? 1 / CHARS_PER_TOKEN)));
 }
 /**
  * The shared half of every "System One" decision provider — a model that takes
@@ -251,6 +288,15 @@ export class SystemOneDecisionProvider extends BaseProvider {
     defaultTimeoutMs(_questionCount) {
         return this.getDescriptorDecideMs();
     }
+    /**
+     * The part of a successful response that holds `answers`, `usage` and
+     * `model`. The default is the response itself; a vendor that wraps every
+     * answer in an envelope returns what is inside it. Errors are not passed
+     * through here: they are read from the whole response.
+     */
+    readDecisionPayload(payload) {
+        return payload;
+    }
     /** Per-question confidence a transport reports outside the answer objects. */
     reportedConfidence(_payload) {
         return {};
@@ -354,7 +400,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 const signal = request.signal
                     ? AbortSignal.any([request.signal, timeout])
                     : timeout;
-                const response = await this.proxyFetch(this.decisionEndpoint(), {
+                const response = await this.proxyFetch(this.decisionEndpoint(resolvedModel), {
                     method: "POST",
                     headers: this.decisionHeaders(),
                     body,
@@ -393,7 +439,8 @@ export class SystemOneDecisionProvider extends BaseProvider {
                     await sleep(retryAfterMs ?? 2 ** attempt * 250 + Math.random() * 250, request.signal);
                     continue;
                 }
-                if (!isRecord(payload) || !isRecord(payload.answers)) {
+                const decoded = this.readDecisionPayload(payload);
+                if (!isRecord(decoded) || !isRecord(decoded.answers)) {
                     throw this.decisionError({
                         kind: "server",
                         message: `${label} returned a response without an answers map.`,
@@ -402,9 +449,9 @@ export class SystemOneDecisionProvider extends BaseProvider {
                         retryable: false,
                     });
                 }
-                const reported = this.reportedConfidence(payload);
+                const reported = this.reportedConfidence(decoded);
                 const answers = {};
-                for (const [id, raw] of Object.entries(payload.answers)) {
+                for (const [id, raw] of Object.entries(decoded.answers)) {
                     const parsed = parseDecisionAnswer(raw, reported[id]);
                     if (parsed) {
                         answers[id] = parsed;
@@ -415,13 +462,13 @@ export class SystemOneDecisionProvider extends BaseProvider {
                         });
                     }
                 }
-                const usage = isRecord(payload.usage) ? payload.usage : {};
+                const usage = isRecord(decoded.usage) ? decoded.usage : {};
                 return {
                     // `resolvedModel`, not `this.modelName`: when the caller pinned a
                     // model for this one request and the response omits its own, the
                     // instance default would be reported instead of the model actually
                     // asked for.
-                    model: this.resolveResponseModel(payload, resolvedModel),
+                    model: this.resolveResponseModel(decoded, resolvedModel),
                     provider: this.providerName,
                     answers,
                     // Two spellings for one field. The System One wire sends
@@ -485,8 +532,9 @@ export class SystemOneDecisionProvider extends BaseProvider {
      * applies to.
      */
     assertWithinRequestBytes(body) {
-        const limit = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)
-            ?.decisionLimits?.media?.maxRequestBytes;
+        const media = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)
+            ?.decisionLimits?.media;
+        const limit = media?.maxRequestBytes;
         if (limit === undefined) {
             return;
         }
@@ -494,7 +542,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
         if (bytes > limit) {
             throw this.decisionError({
                 kind: "invalid_request",
-                message: `The request is ${bytes} bytes; ${this.vendorLabel()} accepts at most ${limit}. Send fewer or smaller images, or a shorter video.`,
+                message: `The request is ${bytes} bytes; ${this.vendorLabel()} accepts at most ${limit}. Send fewer or smaller images${media?.video ? ", or a shorter video" : ""}.`,
                 retryable: false,
             });
         }
@@ -520,7 +568,11 @@ export class SystemOneDecisionProvider extends BaseProvider {
         }
         const modelLimits = limits.models?.[model];
         const maxStateTokens = modelLimits?.maxStateTokens ?? limits.maxStateTokens;
-        const stateTokens = estimateDecisionStateTokens(serializeForEstimate(request.state), modelLimits?.nonAsciiTokensPerChar ?? limits.nonAsciiTokensPerChar);
+        const stateTokens = estimateDecisionStateTokens(serializeForEstimate(request.state), modelLimits?.nonAsciiTokensPerChar ?? limits.nonAsciiTokensPerChar, {
+            digit: limits.digitTokensPerChar,
+            symbol: limits.symbolTokensPerChar,
+            astral: limits.astralTokensPerChar,
+        });
         if (stateTokens > maxStateTokens) {
             throw this.decisionError({
                 kind: "max_tokens_exceeded",

package/dist/types/decision.d.ts

@@ -153,6 +153,28 @@ export type DecisionLimits = {
      * estimate for every character.
      */
     nonAsciiTokensPerChar?: number;
+    /**
+     * Tokens charged per ASCII digit. A tokenizer that reads every digit as its
+     * own token makes numbers, ids and timestamps several times longer than the
+     * default estimate of four characters per token. Absent = digits are
+     * estimated like any other ASCII character.
+     */
+    digitTokensPerChar?: number;
+    /**
+     * Tokens charged per ASCII punctuation or symbol character (`,` `.` `{` `"`
+     * `:` and the like). The same tokenizers that read each digit alone read most
+     * punctuation alone too, so JSON, logs and lists of numbers run far above four
+     * characters a token. Absent = punctuation is estimated like any other ASCII
+     * character.
+     */
+    symbolTokensPerChar?: number;
+    /**
+     * Tokens charged per character outside the Basic Multilingual Plane (emoji
+     * and the like), which is counted separately from `nonAsciiTokensPerChar`
+     * because it costs about twice as much. Absent = charged at
+     * `nonAsciiTokensPerChar`.
+     */
+    astralTokensPerChar?: number;
     /** Per-model limits, keyed by model id; each field overrides the one above. */
     models?: Readonly<Record<string, {
         maxStateTokens: number;

package/dist/types/providerCatalog.d.ts

@@ -56,6 +56,8 @@ export type CatalogErrorRuleClass = "authentication" | "rate-limit" | "invalid-m
 export type CatalogErrorRuleJson = {
     status?: number;
     pattern?: string;
+    /** Restrict the pattern to these HTTP statuses; status matching stays independent. */
+    patternStatuses?: number[];
     class: CatalogErrorRuleClass;
     message: string;
 };

package/dist/types/providers.d.ts

@@ -583,6 +583,19 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    /**
+     * Cloudflare Clef — the `decide` inference type, reached through Workers AI.
+     * The token and account id are the ones the `cloudflare` text provider reads
+     * (`CLOUDFLARE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID`), but this slice is separate
+     * so the two cannot be mixed up. Both are required. `baseURL` is optional and
+     * defaults to `https://api.cloudflare.com/client/v4`; requests go to
+     * `<baseURL>/accounts/<accountId>/ai/run/@cf/cloudflare/<model>`.
+     */
+    cloudflareClef?: {
+        apiKey?: string;
+        accountId?: string;
+        baseURL?: string;
+    };
 };
 /**
  * Voyage AI /embeddings response shape.
@@ -2325,6 +2338,8 @@ export type ProviderDescriptor = {
         extraRequired?: readonly string[];
         /** Alternate ways to satisfy extraRequired when it isn't a plain env-var list (e.g. Vertex's file-path-OR-individual-fields auth). Each entry is either a single env var name (satisfied alone) or a nested array of names that must ALL be present together (e.g. Vertex's GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY pair, which is only valid as a pair). Evaluate with `satisfiesFallbacks()` (providerConfig.ts) rather than re-deriving this logic at each call site. */
         extraRequiredFallbacks?: readonly (string | readonly string[])[];
+        /** For an `extraRequired` name that can also be given in `credentials.<credentialsKey>`: the field of that slice that stands for it (e.g. `{ CLOUDFLARE_ACCOUNT_ID: "accountId" }`). A base URL needs no entry; it is matched through `baseURL` above. */
+        extraRequiredCredentialFields?: Readonly<Record<string, string>>;
         /** True when the provider is usable with zero configuration (local runtime with a documented default URL, or a documented non-secret default like LiteLLM's "sk-anything"). */
         optional?: boolean;
     };

package/dist/utils/modelChoices.js

@@ -2,7 +2,7 @@
  * Centralized model choices for CLI commands
  * Derives choices from model enums to ensure consistency
  */
-import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, SageMakerModels, OpenRouterModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, LayaModels, XorModels, PerplexityDeciderModels, ReplicateModels, } from "../constants/enums.js";
+import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, SageMakerModels, OpenRouterModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, LayaModels, XorModels, PerplexityDeciderModels, CloudflareClefModels, ReplicateModels, } from "../constants/enums.js";
 import { getCatalogJsonEntries } from "../providers/catalog/loader.js";
 /**
  * Looks up the JSON catalog entry for a provider, if it is one of the 11
@@ -399,6 +399,16 @@ const TOP_MODELS_CONFIG = {
             description: "Recommended - Perplexity decision model that also reads images",
         },
     ],
+    [AIProviderName.CLOUDFLARE_CLEF]: [
+        {
+            model: CloudflareClefModels.CLEF,
+            description: "Recommended - Cloudflare Clef 27B decision model that also reads images (state limited to ~2,000 tokens)",
+        },
+        {
+            model: CloudflareClefModels.CLEF_FLASH,
+            description: "Clef-flash 9B - the faster, cheaper Cloudflare decision model (same ~2,000-token state limit)",
+        },
+    ],
     [AIProviderName.AUTO]: [],
 };
 /**
@@ -441,6 +451,7 @@ export const DEFAULT_MODELS = {
     [AIProviderName.LAYA]: LayaModels.TYPED_DECISIONS,
     [AIProviderName.XOR]: XorModels.XOR_1_1,
     [AIProviderName.PERPLEXITY_DECIDER]: PerplexityDeciderModels.PPLX_DECIDER_V1_27B,
+    [AIProviderName.CLOUDFLARE_CLEF]: CloudflareClefModels.CLEF,
 };
 /**
  * Model enum mappings for getAllModels.
@@ -476,6 +487,7 @@ const MODEL_ENUMS = {
     [AIProviderName.LAYA]: LayaModels,
     [AIProviderName.XOR]: XorModels,
     [AIProviderName.PERPLEXITY_DECIDER]: PerplexityDeciderModels,
+    [AIProviderName.CLOUDFLARE_CLEF]: CloudflareClefModels,
     [AIProviderName.AUTO]: null,
 };
 /**

package/dist/utils/pricing.js

@@ -788,6 +788,18 @@ const PRICING = {
         _default: { input: 0.04 / 1_000_000, output: 0 },
         "pplx-decider-v1-27b": { input: 0.04 / 1_000_000, output: 0 },
     },
+    "cloudflare-clef": {
+        // Workers AI bills Clef per million INPUT tokens ($0.24 for clef, $0.09 for
+        // clef-flash); no output price is listed. `output: 0` is a price, not a token
+        // count, so do not "correct" it from `usage.output_tokens`. The `cf-ai-neurons`
+        // response header was checked against the published neuron rates on
+        // 2026-10-03 and matched them exactly (21,818 and 8,182 neurons per million
+        // input tokens). Rates from Cloudflare's Workers AI pricing page. An unknown
+        // model name is priced as clef, the dearer of the two.
+        _default: { input: 0.24 / 1_000_000, output: 0 },
+        clef: { input: 0.24 / 1_000_000, output: 0 },
+        "clef-flash": { input: 0.09 / 1_000_000, output: 0 },
+    },
     stability: {
         // Stability AI bills per image; symbolic per-token rate.
         _default: { input: 0, output: 0.04 / 1_000 },

package/dist/utils/providerConfig.d.ts

@@ -416,3 +416,10 @@ export declare function createXorConfig(): ProviderConfigOptions;
  * provider and has a public endpoint, so the key alone configures it.
  */
 export declare function createPerplexityDeciderConfig(): ProviderConfigOptions;
+/**
+ * Cloudflare Clef — the `decide` inference type, reached through Workers AI,
+ * not the Workers AI text models. It reads the same CLOUDFLARE_API_KEY and
+ * CLOUDFLARE_ACCOUNT_ID as the `cloudflare` text provider; the endpoint is
+ * Cloudflare's own, so the two together configure it.
+ */
+export declare function createCloudflareClefConfig(): ProviderConfigOptions;

package/dist/utils/providerConfig.js

@@ -1376,3 +1376,22 @@ export function createPerplexityDeciderConfig() {
         ],
     };
 }
+/**
+ * Cloudflare Clef — the `decide` inference type, reached through Workers AI,
+ * not the Workers AI text models. It reads the same CLOUDFLARE_API_KEY and
+ * CLOUDFLARE_ACCOUNT_ID as the `cloudflare` text provider; the endpoint is
+ * Cloudflare's own, so the two together configure it.
+ */
+export function createCloudflareClefConfig() {
+    return {
+        providerName: "Cloudflare Clef",
+        envVarName: "CLOUDFLARE_API_KEY",
+        setupUrl: "https://dash.cloudflare.com/profile/api-tokens",
+        description: "API token (Workers AI scope) for Cloudflare's Clef decision models",
+        instructions: [
+            "1. Create an API token with the 'Workers AI: Read + Write' permission (https://dash.cloudflare.com/profile/api-tokens)",
+            "2. Set CLOUDFLARE_API_KEY to it, and CLOUDFLARE_ACCOUNT_ID to your account id (in the dashboard URL, or under 'Account ID'); they are the same settings the Cloudflare text provider reads, so setting them also lets decide() use Clef when no other decision provider is configured",
+            "3. The Clef endpoint ignores state text past about 2,048 tokens, so use it for short decisions",
+        ],
+    };
+}

package/dist/utils/providerRetry.d.ts

@@ -52,6 +52,11 @@ export declare function duckTypedStatusCode(error: unknown): number | undefined;
  * hand-rolled OpenAI-compatible client's record). Shared with baseProvider.
  */
 export declare function extractRetryAfterMsFromError(error: unknown): number | undefined;
+/**
+ * OpenAI's chat transport keeps the type inside the JSON response body,
+ * rather than stamping it onto the raw error.
+ */
+export declare function readOpenAIBodyErrorType(responseBody: unknown): string | undefined;
 /**
  * An OpenAI-wire `insufficient_quota` error: the account is out of credit or
  * has hit a spend cap.

package/dist/utils/providerRetry.js

@@ -105,6 +105,23 @@ export function extractRetryAfterMsFromError(error) {
     }
     return undefined;
 }
+/**
+ * OpenAI's chat transport keeps the type inside the JSON response body,
+ * rather than stamping it onto the raw error.
+ */
+export function readOpenAIBodyErrorType(responseBody) {
+    if (typeof responseBody !== "string") {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(responseBody);
+        const inner = parsed?.error;
+        return typeof inner?.type === "string" ? inner.type : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * An OpenAI-wire `insufficient_quota` error: the account is out of credit or
  * has hit a spend cap.
@@ -130,18 +147,7 @@ export function isOpenAIQuotaExhaustedError(error) {
     if (err.type === "insufficient_quota") {
         return true;
     }
-    // The SDK keeps the raw payload as a string; the type lives inside it.
-    if (typeof err.responseBody === "string") {
-        try {
-            const parsed = JSON.parse(err.responseBody);
-            const inner = parsed?.error;
-            return inner?.type === "insufficient_quota";
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
+    return readOpenAIBodyErrorType(err.responseBody) === "insufficient_quota";
 }
 /**
  * True when `error` is an abort, or wraps one at any depth via `cause`.