@juspay/neurolink 12.55.3 → 12.56.1

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

@@ -60,6 +60,24 @@
         "symbolTokensPerChar": { "type": "number", "exclusiveMinimum": 0 },
         "astralTokensPerChar": { "type": "number", "exclusiveMinimum": 0 },
         "advisory": { "type": "boolean" },
+        "media": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["maxImages", "video", "maxRequestBytes"],
+          "description": "What a request may carry besides text. Requires decide.media, which names the body keys the prepared media is written under.",
+          "properties": {
+            "maxImages": { "type": "integer", "minimum": 1 },
+            "video": {
+              "type": "boolean",
+              "description": "Whether one video is accepted. True requires decide.media.videoKey; false forbids it."
+            },
+            "maxRequestBytes": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "Ceiling on the encoded request body, in bytes."
+            }
+          }
+        },
         "models": {
           "type": "object",
           "description": "Per-model limits keyed by a models.catalog key (enforced by the zod schema).",
@@ -96,7 +114,12 @@
         },
         "baseURLNormalize": {
           "type": "array",
-          "items": { "enum": ["strip-trailing-slash"] }
+          "items": { "enum": ["strip-trailing-slash", "strip-v1-suffix"] },
+          "description": "Applied to the base URL in list order. strip-v1-suffix removes one trailing /v1, in either case."
+        },
+        "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."
         },
         "endpoint": {
           "type": "string",
@@ -116,6 +139,16 @@
             }
           }
         },
+        "media": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["imagesKey"],
+          "description": "Body keys prepared media is written under, after model, state and questions: imagesKey only when the request carries an image, videoKey only when it carries a video, and the two differ. Requires decisionLimits.media; videoKey is required exactly when that allowance's video is true.",
+          "properties": {
+            "imagesKey": { "$ref": "#/definitions/decideMediaKey" },
+            "videoKey": { "$ref": "#/definitions/decideMediaKey" }
+          }
+        },
         "requestIdHeaders": {
           "type": "array",
           "items": {
@@ -156,6 +189,12 @@
                     ]
                   },
                   "statusMin": { "$ref": "#/definitions/httpStatus" },
+                  "messagePattern": {
+                    "type": "string",
+                    "minLength": 1,
+                    "maxLength": 200,
+                    "description": "The rule also needs the error message to match this case-insensitive regular expression (first 2,000 characters, key removed). Bounded: outside a character class no unescaped *, + or {n,}, no quantifier on a group, no count above 255, and the counts side by side multiply to at most 4,096 ways (each ? is 2, each {n,m} is m-n+1)."
+                  },
                   "kind": { "$ref": "#/definitions/decisionErrorKind" },
                   "retryable": { "type": "boolean" }
                 }
@@ -595,6 +634,20 @@
   },
   "definitions": {
     "httpStatus": { "type": "integer", "minimum": 100, "maximum": 599 },
+    "decideMediaKey": {
+      "type": "string",
+      "pattern": "^[A-Za-z][A-Za-z0-9_]*$",
+      "not": {
+        "enum": [
+          "model",
+          "state",
+          "questions",
+          "__proto__",
+          "constructor",
+          "prototype"
+        ]
+      }
+    },
     "decisionErrorKind": {
       "enum": [
         "authentication",

package/dist/providers/catalog/schema.js

@@ -397,11 +397,97 @@ const decideErrorKindSchema = z.enum([
     "timeout",
     "network",
 ]);
+// The most steps one `{n}` or `{n,m}` may stand for.
+const MAX_PATTERN_COUNT = 255;
+// The most ways a pattern's counts may multiply: each `?` is 2 and each `{n,m}`
+// is m-n+1. Adjacent bounded counts multiply on a miss (`.{0,255}` three times
+// took 38 s on one 2,000-character message), and a miss on a 5xx is retried.
+// XOR's pattern is 3,362.
+const MAX_PATTERN_WAYS = 4096;
+// What can make a pattern backtrack catastrophically on an error message, so
+// that a catalog author cannot write it: `*`, `+` and an open-ended `{n,}` have
+// no upper bound; any quantifier on a group (`(a|a){0,30}`, `(ab)?`) repeats
+// whatever its alternatives match, and quantifiers nested that way multiply; a
+// count above MAX_PATTERN_COUNT is as good as no bound. A quantifier on a plain
+// character, class or escape is fine. Inside a character class all of them are
+// plain characters, and a backslash makes the next one plain everywhere.
+// Counts that sit side by side multiply, so their product has a budget too
+// (MAX_PATTERN_WAYS); within it a pattern is still not a guarantee of linear
+// time, and wants reading.
+function hasRiskyQuantifier(pattern) {
+    const count = /\{(\d+)(?:,(\d*))?\}/y;
+    let inClass = false;
+    let afterGroup = false;
+    let ways = 1;
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        const onGroup = afterGroup;
+        afterGroup = false;
+        if (char === "\\") {
+            index += 1;
+        }
+        else if (inClass) {
+            inClass = char !== "]";
+        }
+        else if (char === "[") {
+            inClass = true;
+        }
+        else if (char === ")") {
+            afterGroup = true;
+        }
+        else if (char === "*" || char === "+" || (char === "?" && onGroup)) {
+            return true;
+        }
+        else if (char === "?") {
+            // The `?` that opens a group (`(?:`, `(?=`) is not a quantifier.
+            if (pattern[index - 1] !== "(") {
+                ways *= 2;
+            }
+        }
+        else if (char === "{") {
+            count.lastIndex = index;
+            const found = count.exec(pattern);
+            if (found &&
+                (onGroup ||
+                    found[2] === "" ||
+                    Math.max(Number(found[1]), Number(found[2] ?? 0)) > MAX_PATTERN_COUNT)) {
+                return true;
+            }
+            if (found && found[2] !== undefined) {
+                ways *= Number(found[2]) - Number(found[1]) + 1;
+            }
+        }
+        if (ways > MAX_PATTERN_WAYS) {
+            return true;
+        }
+    }
+    return false;
+}
+function compilesAsPattern(pattern) {
+    try {
+        new RegExp(pattern, "i");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const decideMessagePatternSchema = z
+    .string()
+    .min(1)
+    .max(200)
+    .refine(compilesAsPattern, {
+    message: "messagePattern is not a valid regular expression",
+})
+    .refine((pattern) => !hasRiskyQuantifier(pattern), {
+    message: "messagePattern must be bounded: an unescaped * or +, an open-ended {n,}, a {n,m} count above 255, or any quantifier on a group, outside a character class, can backtrack catastrophically on an error message. Put ?, or {n,m} up to 255, only on a plain character, a character class or an escape, and keep the counts side by side to 4096 ways in all (each ? is 2, each {n,m} is m-n+1)",
+});
 const decideErrorRuleSchema = z.strictObject({
     status: z
         .union([decideStatusSchema, z.array(decideStatusSchema).min(1)])
         .optional(),
     statusMin: decideStatusSchema.optional(),
+    messagePattern: decideMessagePatternSchema.optional(),
     kind: decideErrorKindSchema,
     retryable: z.boolean().optional(),
 });
@@ -434,16 +520,45 @@ const decideBodyShapeSchema = z
     path: ["formatter"],
     message: "a body shape sets isArray: true together with a formatter, or neither: an array without a formatter never matches, and a formatter on a body that is not an array reads the text as an empty list",
 });
+// The keys the body already uses, and the names an object must not take as an
+// own key from data.
+const RESERVED_MEDIA_KEYS = new Set([
+    "model",
+    "state",
+    "questions",
+    "__proto__",
+    "constructor",
+    "prototype",
+]);
+const decideMediaKeySchema = z
+    .string()
+    .regex(/^[A-Za-z][A-Za-z0-9_]*$/, "a media key must start with a letter and use only letters, digits and underscores")
+    .refine((key) => !RESERVED_MEDIA_KEYS.has(key), {
+    message: "a media key must not be model, state, questions, __proto__, constructor or prototype",
+});
+const decideMediaSchema = z
+    .strictObject({
+    imagesKey: decideMediaKeySchema,
+    videoKey: decideMediaKeySchema.optional(),
+})
+    .refine((media) => media.imagesKey !== media.videoKey, {
+    path: ["videoKey"],
+    message: "decide.media.videoKey must differ from imagesKey: one body key cannot carry both",
+});
 const decideBlockSchema = z.strictObject({
     dialect: z.enum(["system-one"]),
     order: decidePositiveInt,
     baseURLRequired: z.boolean().optional(),
-    baseURLNormalize: z.array(z.enum(["strip-trailing-slash"])).optional(),
+    baseURLNormalize: z
+        .array(z.enum(["strip-trailing-slash", "strip-v1-suffix"]))
+        .optional(),
+    baseURLShape: z.enum(["origin"]).optional(),
     endpoint: decideEndpointSchema,
     model: z.strictObject({
         placement: z.enum(["body", "body-unless-alias"]),
         alias: z.string().min(1).optional(),
     }),
+    media: decideMediaSchema.optional(),
     requestIdHeaders: z.array(decideHeaderNameSchema).optional(),
     response: z
         .strictObject({ modelPaths: z.array(decidePathSchema).optional() })
@@ -487,7 +602,9 @@ const decideModelsSchema = z
         }
     }
 });
-// `media` is deliberately absent: no decide provider migrated yet needs it.
+// `media` is the allowance the base class prepares and gates a request's images
+// and video against; `decide.media` names the body keys they go out under, and
+// the entry refinement below requires the two together.
 const decideLimitsSchema = z.strictObject({
     maxStateTokens: decidePositiveInt,
     maxQuestions: decidePositiveInt.optional(),
@@ -501,6 +618,13 @@ const decideLimitsSchema = z.strictObject({
         nonAsciiTokensPerChar: decidePositiveNumber.optional(),
     }))
         .optional(),
+    media: z
+        .strictObject({
+        maxImages: decidePositiveInt,
+        video: z.boolean(),
+        maxRequestBytes: decidePositiveInt,
+    })
+        .optional(),
     advisory: z.boolean().optional(),
 });
 const decideCatalogJsonSchema = z
@@ -523,6 +647,8 @@ const decideCatalogJsonSchema = z
     const issue = (path, message) => {
         ctx.addIssue({ code: "custom", path, message });
     };
+    // Two rules collide only on the same status AND the same pattern: XOR
+    // lists a pattern rule and a plain rule at one statusMin.
     const seenStatus = new Set();
     const seenStatusMin = new Set();
     decide.errors.rules.forEach((rule, index) => {
@@ -531,17 +657,21 @@ const decideCatalogJsonSchema = z
             issue(at, "errors.rules entry needs exactly one of status or statusMin");
         }
         const statuses = typeof rule.status === "number" ? [rule.status] : (rule.status ?? []);
+        const sameAs = rule.messagePattern === undefined
+            ? ""
+            : " with the same messagePattern";
+        const keyOf = (value) => JSON.stringify([value, rule.messagePattern ?? null]);
         for (const status of statuses) {
-            if (seenStatus.has(status)) {
-                issue([...at, "status"], `errors.rules lists status ${status} more than once`);
+            if (seenStatus.has(keyOf(status))) {
+                issue([...at, "status"], `errors.rules lists status ${status} more than once${sameAs}`);
             }
-            seenStatus.add(status);
+            seenStatus.add(keyOf(status));
         }
         if (rule.statusMin !== undefined) {
-            if (seenStatusMin.has(rule.statusMin)) {
-                issue([...at, "statusMin"], `errors.rules lists statusMin ${rule.statusMin} more than once`);
+            if (seenStatusMin.has(keyOf(rule.statusMin))) {
+                issue([...at, "statusMin"], `errors.rules lists statusMin ${rule.statusMin} more than once${sameAs}`);
             }
-            seenStatusMin.add(rule.statusMin);
+            seenStatusMin.add(keyOf(rule.statusMin));
         }
     });
     const modelKeys = new Set(Object.keys(entry.models.catalog));
@@ -573,6 +703,22 @@ const decideCatalogJsonSchema = z
             issue(["decisionLimits", "models", id], "decisionLimits.models key must be a key of models.catalog");
         }
     }
+    const mediaKeys = decide.media;
+    const mediaAllowance = entry.decisionLimits?.media;
+    if (mediaKeys !== undefined && mediaAllowance === undefined) {
+        issue(["decide", "media"], "decide.media needs decisionLimits.media: without an allowance the base class refuses every image and video, so these keys would never be written");
+    }
+    if (mediaKeys === undefined && mediaAllowance !== undefined) {
+        issue(["decisionLimits", "media"], "decisionLimits.media needs decide.media: without body keys the engine would prepare a request's media and then leave it out of the body");
+    }
+    if (mediaKeys !== undefined && mediaAllowance !== undefined) {
+        if (mediaAllowance.video && mediaKeys.videoKey === undefined) {
+            issue(["decide", "media", "videoKey"], "decide.media.videoKey is required when decisionLimits.media.video is true");
+        }
+        if (!mediaAllowance.video && mediaKeys.videoKey !== undefined) {
+            issue(["decide", "media", "videoKey"], "decide.media.videoKey must be omitted when decisionLimits.media.video is false");
+        }
+    }
     if (decide.baseURLRequired === true &&
         !decide.endpoint.includes("{baseURL}")) {
         issue(["decide", "endpoint"], "decide.endpoint must contain {baseURL} when decide.baseURLRequired is true");

package/dist/providers/catalog/xor.json

@@ -0,0 +1,86 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "xor",
+    "displayName": "XOR",
+    "aliases": [],
+    "inferenceKinds": ["decide"],
+    "wire": {},
+    "models": {
+        "default": "xor-1.1",
+        "topModels": ["xor-1.1"],
+        "catalog": {
+            "xor-1.1": {
+                "contextWindow": 250000,
+                "maxOutputTokens": 256,
+                "vision": false,
+                "status": "production",
+                "description": "Recommended - XOR 1.1, decision model that also reads images and video"
+            }
+        }
+    },
+    "timeouts": { "decideMs": 5000 },
+    "decisionLimits": {
+        "maxStateTokens": 200000,
+        "nonAsciiTokensPerChar": 1,
+        "media": { "maxImages": 8, "video": true, "maxRequestBytes": 8388608 }
+    },
+    "decide": {
+        "dialect": "system-one",
+        "order": 3,
+        "baseURLRequired": true,
+        "baseURLNormalize": ["strip-trailing-slash", "strip-v1-suffix"],
+        "baseURLShape": "origin",
+        "endpoint": "{baseURL}/v1/systemone",
+        "model": { "placement": "body" },
+        "media": { "imagesKey": "images", "videoKey": "video" },
+        "requestIdHeaders": [
+            "x-request-id",
+            "x-typesafe-request-id",
+            "x-litellm-call-id"
+        ],
+        "errors": {
+            "rules": [
+                { "status": 401, "kind": "authentication" },
+                { "status": 413, "kind": "max_tokens_exceeded" },
+                { "status": 429, "kind": "rate_limit" },
+                { "status": 503, "kind": "overloaded" },
+                {
+                    "statusMin": 500,
+                    "messagePattern": "(context|prefill|prompt).{0,40}(length|limit|too long|exceed)|(too long|exceeds?).{0,40}(context|tokens)",
+                    "kind": "max_tokens_exceeded"
+                },
+                { "statusMin": 500, "kind": "server" }
+            ],
+            "default": "invalid_request",
+            "bodyShapes": [
+                { "path": "error.message" },
+                { "path": "error" },
+                {
+                    "path": "detail",
+                    "isArray": true,
+                    "formatter": "fastapi-validation"
+                },
+                { "path": "detail" }
+            ]
+        }
+    },
+    "setup": {
+        "url": "https://huggingface.co/juspay/xor",
+        "apiKeyFormat": null,
+        "billingPolicy": "free-tier",
+        "description": "API key for your XOR endpoint",
+        "instructions": [
+            "1. Reach an XOR deployment, or use a LiteLLM proxy with a pass-through route to one",
+            "2. Set XOR_BASE_URL to its origin (NeuroLink calls <XOR_BASE_URL>/v1/systemone)",
+            "3. Set {apiKeyEnvVar} to the key it accepts (on LiteLLM, a virtual key whose team allows xor-1.1)"
+        ]
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-29",
+            "method": "The single model id xor-1.1 is the roster the hand-written XOR descriptor shipped; 2026-09-29 is the date it was added, not a date it was checked. The roster was never verified against a live XOR endpoint, and no live probe was run in this change"
+        },
+        "liveMatrix": null,
+        "addedInPR": "https://github.com/juspay/neurolink/pull/1984"
+    }
+}

package/dist/providers/configuredDecision.d.ts

@@ -1,4 +1,4 @@
-import type { DecideCatalogJson, DecisionDialect, DecisionError, DecisionState, UnknownRecord } from "../types/index.js";
+import type { DecideCatalogJson, DecisionDialect, DecisionError, DecisionPreparedMedia, DecisionState, UnknownRecord } from "../types/index.js";
 import { SystemOneDecisionProvider } from "./systemOneDecision.js";
 /** A `decide` provider described entirely by its catalog entry. */
 export declare class ConfiguredDecisionProvider extends SystemOneDecisionProvider {
@@ -15,7 +15,7 @@ export declare class ConfiguredDecisionProvider extends SystemOneDecisionProvide
     protected missingConfigMessage(): string | undefined;
     protected decisionEndpoint(): string;
     protected decisionHeaders(): Record<string, string>;
-    protected buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string): Record<string, unknown>;
+    protected buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string, media?: DecisionPreparedMedia): Record<string, unknown>;
     protected parseDecisionError(status: number, payload: unknown, requestId: string | undefined): DecisionError;
     protected readRequestId(headers: Headers): string | undefined;
     protected resolveResponseModel(payload: Record<string, unknown>, requestedModel: string): string;

package/dist/providers/configuredDecision.js

@@ -2,7 +2,7 @@ import { logger } from "../utils/logger.js";
 import { redactUrlForError } from "../utils/logSanitize.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { catalogCredentialsKey, catalogEnvVar } from "./catalog/loader.js";
-import { normalizeBaseURL } from "./decide/baseUrl.js";
+import { baseURLShapeProblem, normalizeBaseURL } from "./decide/baseUrl.js";
 import { getDecisionDialect } from "./decide/dialects/index.js";
 import { classifyDecisionError } from "./decide/errors.js";
 import { isRecord } from "./decide/guards.js";
@@ -54,8 +54,14 @@ export class ConfiguredDecisionProvider extends SystemOneDecisionProvider {
         return `${this.entry.displayName} requires an API key. Set ${catalogEnvVar(this.entry, "apiKey")} or pass credentials.${catalogCredentialsKey(this.entry)}.apiKey.`;
     }
     missingConfigMessage() {
-        return this.entry.decide.baseURLRequired && !this.baseURL
-            ? `${this.entry.displayName} requires a base URL. Set ${catalogEnvVar(this.entry, "baseURL")} or pass credentials.${catalogCredentialsKey(this.entry)}.baseURL.`
+        const { baseURLRequired, baseURLShape } = this.entry.decide;
+        if (!this.baseURL) {
+            return baseURLRequired
+                ? `${this.entry.displayName} requires a base URL. Set ${catalogEnvVar(this.entry, "baseURL")} or pass credentials.${catalogCredentialsKey(this.entry)}.baseURL.`
+                : undefined;
+        }
+        return baseURLShape
+            ? baseURLShapeProblem(baseURLShape, this.baseURL, this.entry.displayName, `Set ${catalogEnvVar(this.entry, "baseURL")} or pass credentials.${catalogCredentialsKey(this.entry)}.baseURL to the origin, and give the key through ${catalogEnvVar(this.entry, "apiKey")} or credentials.${catalogCredentialsKey(this.entry)}.apiKey.`)
             : undefined;
     }
     decisionEndpoint() {
@@ -67,11 +73,22 @@ export class ConfiguredDecisionProvider extends SystemOneDecisionProvider {
             "Content-Type": "application/json",
         };
     }
-    buildDecisionBody(state, questions, model) {
+    buildDecisionBody(state, questions, model, media) {
         const { placement, alias } = this.entry.decide.model;
-        return placement === "body-unless-alias" && model === alias
+        const body = placement === "body-unless-alias" && model === alias
             ? { state, questions }
             : { model, state, questions };
+        const keys = this.entry.decide.media;
+        if (!keys || !media) {
+            return body;
+        }
+        // A key is written only for media the request carries: a server may refuse
+        // an empty `images`.
+        return {
+            ...body,
+            ...(media.images.length > 0 ? { [keys.imagesKey]: media.images } : {}),
+            ...(media.video && keys.videoKey ? { [keys.videoKey]: media.video } : {}),
+        };
     }
     parseDecisionError(status, payload, requestId) {
         return classifyDecisionError(this.entry.decide.errors, {

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

@@ -1,2 +1,4 @@
-import type { DecideBaseURLTransform } from "../../types/index.js";
+import type { DecideBaseURLShape, DecideBaseURLTransform } from "../../types/index.js";
 export declare function normalizeBaseURL(raw: string, transforms: readonly DecideBaseURLTransform[]): string;
+/** 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;

package/dist/providers/decide/baseUrl.js

@@ -8,7 +8,50 @@ const TRANSFORMS = {
         }
         return value.slice(0, end);
     },
+    // A fixed-width tail check, not a pattern: nothing here can backtrack.
+    "strip-v1-suffix": (value) => {
+        const start = value.length - 3;
+        return start >= 0 &&
+            value[start] === "/" &&
+            (value[start + 1] === "v" || value[start + 1] === "V") &&
+            value[start + 2] === "1"
+            ? value.slice(0, start)
+            : value;
+    },
 };
 export function normalizeBaseURL(raw, transforms) {
     return transforms.reduce((value, name) => TRANSFORMS[name](value), raw);
 }
+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
+    // string or fragment ends up inside it.
+    origin: (baseURL, displayName, fix) => {
+        try {
+            const url = new URL(baseURL);
+            // `new URL()` accepts any scheme, so a host:port with no scheme parses as
+            // one (`xor.internal:8080` has the scheme `xor.internal:`) and would reach
+            // `fetch` as a network error instead of this message.
+            if (url.protocol !== "https:" && url.protocol !== "http:") {
+                return `The ${displayName} base URL must start with https:// or http://. ${fix}`;
+            }
+            // 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 ||
+                url.password ||
+                url.search ||
+                url.hash ||
+                baseURL.includes("?") ||
+                baseURL.includes("#")
+                ? `The ${displayName} base URL must not carry credentials, a query string or a fragment. ${fix}`
+                : undefined;
+        }
+        catch {
+            return `The ${displayName} base URL is not a valid absolute URL. ${fix}`;
+        }
+    },
+};
+/** Why a normalised base URL fails the shape, or undefined when it passes. */
+export function baseURLShapeProblem(shape, baseURL, displayName, fix) {
+    return SHAPE_CHECKS[shape](baseURL, displayName, fix);
+}

package/dist/providers/decide/errors.js

@@ -7,14 +7,29 @@ const RETRYABLE_BY_DEFAULT = new Set([
     "server",
 ]);
 const isRetryableByDefault = (kind) => RETRYABLE_BY_DEFAULT.has(kind);
-function ruleMatches(rule, status) {
+// The window a messagePattern is searched in: an error body can be arbitrarily
+// long, and a pattern only needs the start of it.
+const MESSAGE_MATCH_LIMIT = 2000;
+const COMPILED_PATTERNS = new Map();
+function compilePattern(source) {
+    const cached = COMPILED_PATTERNS.get(source);
+    if (cached) {
+        return cached;
+    }
+    const compiled = new RegExp(source, "i");
+    COMPILED_PATTERNS.set(source, compiled);
+    return compiled;
+}
+function ruleMatches(rule, status, message) {
     const statuses = rule.status === undefined
         ? []
         : typeof rule.status === "number"
             ? [rule.status]
             : rule.status;
-    return (statuses.includes(status) ||
-        (rule.statusMin !== undefined && status >= rule.statusMin));
+    return ((statuses.includes(status) ||
+        (rule.statusMin !== undefined && status >= rule.statusMin)) &&
+        (rule.messagePattern === undefined ||
+            compilePattern(rule.messagePattern).test(message.slice(0, MESSAGE_MATCH_LIMIT))));
 }
 function messageFromShape(shape, value) {
     if (shape.isArray) {
@@ -27,31 +42,42 @@ function messageFromShape(shape, value) {
     }
     return shape.formatter ? DECIDE_FORMATTERS[shape.formatter](value) : value;
 }
+function firstShapeText(shapes, payload) {
+    for (const shape of shapes) {
+        const text = messageFromShape(shape, readPath(payload, shape.path));
+        if (text !== undefined) {
+            return { shape, text };
+        }
+    }
+    return undefined;
+}
 export function classifyDecisionError(spec, input) {
     const { status, payload, requestId, label, apiKey } = input;
-    const rule = spec.rules.find((candidate) => ruleMatches(candidate, status));
-    const ruleKind = rule?.kind ?? spec.default;
-    const ruleRetryable = rule?.retryable ?? isRetryableByDefault(ruleKind);
     // Redacted once, here: it stands in for a shape's text that redaction
     // empties, and the label is catalog data a key can match. Redaction is not
     // idempotent for a key such as "e" (it matches inside "[redacted]"), so the
     // fallback is never passed through it a second time.
     const fallback = redactCredentials(`${label} request failed with HTTP ${status}`, apiKey);
-    const build = (kind, retryable, text) => ({
+    const found = firstShapeText(spec.bodyShapes, payload);
+    // The message comes first because a rule may match on it: the key is gone
+    // from the text a pattern sees.
+    const message = (found?.text && redactCredentials(found.text, apiKey)) || fallback;
+    const rule = spec.rules.find((candidate) => ruleMatches(candidate, status, message));
+    const ruleKind = rule?.kind ?? spec.default;
+    const ruleRetryable = rule?.retryable ?? isRetryableByDefault(ruleKind);
+    const build = (kind, retryable) => ({
         kind,
-        message: (text && redactCredentials(text, apiKey)) || fallback,
+        message,
         status,
         requestId,
         retryable,
     });
-    for (const shape of spec.bodyShapes) {
-        const text = messageFromShape(shape, readPath(payload, shape.path));
-        if (text !== undefined) {
-            return build(shape.kind ?? ruleKind, shape.retryable ??
-                (shape.kind === undefined
-                    ? ruleRetryable
-                    : isRetryableByDefault(shape.kind)), text);
-        }
+    if (found) {
+        const { shape } = found;
+        return build(shape.kind ?? ruleKind, shape.retryable ??
+            (shape.kind === undefined
+                ? ruleRetryable
+                : isRetryableByDefault(shape.kind)));
     }
     return build(ruleKind, ruleRetryable);
 }

package/dist/types/index.d.ts

@@ -103,3 +103,4 @@ export * from "./dispatch.js";
 export * from "./proxyRestart.js";
 export * from "./proxyBudget.js";
 export * from "./decision.js";
+export * from "./ollamaDiagnostics.js";

package/dist/types/index.js

@@ -119,3 +119,4 @@ export * from "./proxyRestart.js";
 export * from "./proxyBudget.js";
 // `decide` inference-type contracts (TypeSafe Jev is the first provider)
 export * from "./decision.js";
+export * from "./ollamaDiagnostics.js";

package/dist/types/ollamaDiagnostics.d.ts

@@ -0,0 +1,31 @@
+/** Native Ollama diagnostic identity, outcome and captured policy state. */
+export type OllamaDiagnosticContext = Readonly<{
+    /** Private resolved URL: never include it, its key, or credentials in logs. */
+    url: string;
+    key: string;
+    model: string;
+}>;
+export type OllamaDiagnosticSnapshot = Readonly<{
+    count: number;
+    lastFailureAt: number | undefined;
+    revision: number;
+    generation: number;
+}>;
+export type OllamaDiagnosticState = {
+    count: number;
+    lastFailureAt: number | undefined;
+    revision: number;
+    generation: number;
+};
+export type OllamaDiagnosticPermit = Readonly<{
+    kind: "allowed";
+    context: OllamaDiagnosticContext;
+    generation: number;
+}>;
+export type OllamaDiagnosticGate = OllamaDiagnosticPermit | Readonly<{
+    kind: "suppressed";
+    count: number;
+    reason: string;
+    generation: number;
+}>;
+export type OllamaDiagnosticOutcome = "success" | "transport-failure" | "protocol-failure" | "not-run";

package/dist/types/ollamaDiagnostics.js

@@ -0,0 +1 @@
+export {};