@juspay/neurolink 12.49.20 → 12.51.0

package/dist/providers/catalog/schema.js

@@ -31,76 +31,89 @@ const catalogModelSpecSchema = z.strictObject({
         .regex(IDENTIFIER_PATTERN, "enumMember must be a valid identifier")
         .optional(),
 });
-const catalogWireSchema = z
-    .strictObject({
-    baseURL: z.string().optional(),
-    baseURLTemplate: z.string().optional(),
-    extraCredentials: z.array(z.string()).optional(),
-    missingCredentialMessage: z.string().optional(),
-    apiKeyFallbackEnvVars: z.array(z.string()).optional(),
-    envOverrides: z
+function buildWireSchema(requireExactlyOneBaseURL) {
+    return z
         .strictObject({
-        apiKey: z.string().optional(),
         baseURL: z.string().optional(),
-        model: z.string().optional(),
+        baseURLTemplate: z.string().optional(),
+        extraCredentials: z.array(z.string()).optional(),
+        missingCredentialMessage: z.string().optional(),
+        apiKeyFallbackEnvVars: z.array(z.string()).optional(),
+        envOverrides: z
+            .strictObject({
+            apiKey: z.string().optional(),
+            baseURL: z.string().optional(),
+            model: z.string().optional(),
+        })
+            .optional(),
     })
-        .optional(),
-})
-    .superRefine((wire, ctx) => {
-    const hasBaseURL = wire.baseURL !== undefined;
-    const hasTemplate = wire.baseURLTemplate !== undefined;
-    if (hasBaseURL === hasTemplate) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["baseURL"],
-            message: "wire requires exactly one of baseURL or baseURLTemplate",
-        });
-    }
-    if (wire.extraCredentials !== undefined) {
-        if (wire.extraCredentials.length !== 1) {
+        .superRefine((wire, ctx) => {
+        const hasBaseURL = wire.baseURL !== undefined;
+        const hasTemplate = wire.baseURLTemplate !== undefined;
+        if (requireExactlyOneBaseURL && hasBaseURL === hasTemplate) {
             ctx.addIssue({
                 code: "custom",
-                path: ["extraCredentials"],
-                message: "wire.extraCredentials must have exactly one entry",
+                path: ["baseURL"],
+                message: "wire requires exactly one of baseURL or baseURLTemplate",
             });
         }
-        else if (!IDENTIFIER_PATTERN.test(wire.extraCredentials[0])) {
-            // Embedded verbatim in generated credential typing — a non-identifier
-            // value would emit invalid TypeScript.
-            ctx.addIssue({
-                code: "custom",
-                path: ["extraCredentials", 0],
-                message: "wire.extraCredentials entry must be a valid identifier",
-            });
+        if (wire.extraCredentials !== undefined) {
+            if (wire.extraCredentials.length !== 1) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["extraCredentials"],
+                    message: "wire.extraCredentials must have exactly one entry",
+                });
+            }
+            else if (!IDENTIFIER_PATTERN.test(wire.extraCredentials[0])) {
+                // Embedded verbatim in generated credential typing — a non-identifier
+                // value would emit invalid TypeScript.
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["extraCredentials", 0],
+                    message: "wire.extraCredentials entry must be a valid identifier",
+                });
+            }
+            if (!hasTemplate) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["extraCredentials"],
+                    message: "wire.extraCredentials is only valid with baseURLTemplate",
+                });
+            }
         }
-        if (!hasTemplate) {
+        if (wire.missingCredentialMessage !== undefined && !hasTemplate) {
             ctx.addIssue({
                 code: "custom",
-                path: ["extraCredentials"],
-                message: "wire.extraCredentials is only valid with baseURLTemplate",
+                path: ["missingCredentialMessage"],
+                message: "wire.missingCredentialMessage is only valid with baseURLTemplate",
             });
         }
-    }
-    if (wire.missingCredentialMessage !== undefined && !hasTemplate) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["missingCredentialMessage"],
-            message: "wire.missingCredentialMessage is only valid with baseURLTemplate",
-        });
-    }
-    if (hasTemplate &&
-        wire.extraCredentials !== undefined &&
-        wire.extraCredentials.length === 1) {
-        const placeholder = `{${wire.extraCredentials[0]}}`;
-        if (!wire.baseURLTemplate?.includes(placeholder)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["baseURLTemplate"],
-                message: "wire.baseURLTemplate must contain the extraCredentials[0] placeholder",
-            });
+        if (hasTemplate &&
+            wire.extraCredentials !== undefined &&
+            wire.extraCredentials.length === 1) {
+            const placeholder = `{${wire.extraCredentials[0]}}`;
+            if (!wire.baseURLTemplate?.includes(placeholder)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["baseURLTemplate"],
+                    message: "wire.baseURLTemplate must contain the extraCredentials[0] placeholder",
+                });
+            }
         }
-    }
-});
+    });
+}
+const catalogWireSchema = buildWireSchema(true);
+const decideWireSchema = buildWireSchema(false);
+// Chat providers read these; ConfiguredDecisionProvider does not. Accepting one
+// would give a descriptor that says "configured" next to a provider that
+// ignores the setting, so each is refused until the engine reads it.
+const UNSUPPORTED_DECIDE_WIRE_KEYS = [
+    "baseURLTemplate",
+    "extraCredentials",
+    "missingCredentialMessage",
+    "apiKeyFallbackEnvVars",
+];
 const catalogErrorRuleClassSchema = z.enum([
     "authentication",
     "rate-limit",
@@ -342,7 +355,7 @@ const catalogModelsSchema = z
         }
     }
 });
-export const providerCatalogJsonSchema = z.strictObject({
+const catalogIdentityShape = {
     $schema: z.string().optional(),
     id: z.string().regex(KEBAB_ID_PATTERN, "id must be kebab-case"),
     displayName: z.string(),
@@ -355,7 +368,10 @@ export const providerCatalogJsonSchema = z.strictObject({
         .regex(IDENTIFIER_PATTERN, "credentialsKey must be a valid identifier")
         .optional(),
     aliases: z.array(z.string()),
-    tier: z.literal(2),
+};
+export const providerCatalogJsonSchema = z.strictObject({
+    ...catalogIdentityShape,
+    tier: z.literal(2).optional(),
     wire: catalogWireSchema,
     models: catalogModelsSchema,
     capabilities: catalogCapabilitiesSchema,
@@ -366,7 +382,265 @@ export const providerCatalogJsonSchema = z.strictObject({
     setup: catalogSetupSchema,
     evidence: catalogEvidenceSchema,
 });
+const decideStatusSchema = z.number().int().min(100).max(599);
+const decidePositiveInt = z.number().int().positive();
+const decidePositiveNumber = z.number().positive();
+const decideErrorKindSchema = z.enum([
+    "authentication",
+    "invalid_request",
+    "max_tokens_exceeded",
+    "rate_limit",
+    "overloaded",
+    "server",
+    "timeout",
+    "network",
+]);
+const decideErrorRuleSchema = z.strictObject({
+    status: z
+        .union([decideStatusSchema, z.array(decideStatusSchema).min(1)])
+        .optional(),
+    statusMin: decideStatusSchema.optional(),
+    kind: decideErrorKindSchema,
+    retryable: z.boolean().optional(),
+});
+const UNSAFE_PATH_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
+const HTTP_TOKEN_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+const decidePathSchema = z
+    .string()
+    .refine((path) => /^[^.\s]+(?:\.[^.\s]+)*$/.test(path) &&
+    path.split(".").every((segment) => !UNSAFE_PATH_SEGMENTS.has(segment)), {
+    message: "path must be dot-separated segments without whitespace, and must not use __proto__, constructor or prototype",
+});
+const decideHeaderNameSchema = z
+    .string()
+    .regex(HTTP_TOKEN_PATTERN, "header name must be an HTTP token");
+const decideEndpointSchema = z
+    .string()
+    .refine((endpoint) => endpoint.trim().length > 0 &&
+    !/[{}]/.test(endpoint.split("{baseURL}").join("")), {
+    message: "endpoint must not be blank and may only use the {baseURL} placeholder",
+});
+const decideBodyShapeSchema = z
+    .strictObject({
+    path: decidePathSchema,
+    isArray: z.boolean().optional(),
+    formatter: z.enum(["fastapi-validation"]).optional(),
+    kind: decideErrorKindSchema.optional(),
+    retryable: z.boolean().optional(),
+})
+    .refine((shape) => (shape.formatter !== undefined) === (shape.isArray === true), {
+    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",
+});
+const decideBlockSchema = z.strictObject({
+    dialect: z.enum(["system-one"]),
+    order: decidePositiveInt,
+    baseURLRequired: z.boolean().optional(),
+    baseURLNormalize: z.array(z.enum(["strip-trailing-slash"])).optional(),
+    endpoint: decideEndpointSchema,
+    model: z.strictObject({
+        placement: z.enum(["body", "body-unless-alias"]),
+        alias: z.string().min(1).optional(),
+    }),
+    requestIdHeaders: z.array(decideHeaderNameSchema).optional(),
+    response: z
+        .strictObject({ modelPaths: z.array(decidePathSchema).optional() })
+        .optional(),
+    errors: z.strictObject({
+        rules: z.array(decideErrorRuleSchema),
+        default: decideErrorKindSchema,
+        bodyShapes: z.array(decideBodyShapeSchema),
+    }),
+});
+// A window of 0 or less would reach every reader of the derived model manifest,
+// and a model without its own window inherits the default's through `??`,
+// which keeps a 0. Chat entries keep the looser catalogModelSpecSchema.
+const decideModelSpecSchema = catalogModelSpecSchema.extend({
+    contextWindow: decidePositiveInt.optional(),
+    maxOutputTokens: decidePositiveInt.optional(),
+});
+// Here and not in the entry-level refinement below: that one does not run once
+// a sibling field fails a type check, and an author who deletes the TODO lines
+// of a scaffold should see these gaps beside the other errors.
+const decideModelsSchema = z
+    .strictObject({
+    default: z.string(),
+    catalog: z.record(z.string(), decideModelSpecSchema),
+    topModels: z.array(z.string()).min(1).optional(),
+    testModel: z.string().min(1).optional(),
+})
+    .superRefine((models, ctx) => {
+    // The "must be a key" rule reports a default that is not an own key.
+    if (!Object.hasOwn(models.catalog, models.default)) {
+        return;
+    }
+    const base = models.catalog[models.default];
+    for (const field of ["contextWindow", "maxOutputTokens"]) {
+        if (base[field] === undefined) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["catalog", models.default, field],
+                message: `${field} is required on the default model; the derived model manifest reads it`,
+            });
+        }
+    }
+});
+// `media` is deliberately absent: no decide provider migrated yet needs it.
+const decideLimitsSchema = z.strictObject({
+    maxStateTokens: decidePositiveInt,
+    maxQuestions: decidePositiveInt.optional(),
+    nonAsciiTokensPerChar: decidePositiveNumber.optional(),
+    digitTokensPerChar: decidePositiveNumber.optional(),
+    symbolTokensPerChar: decidePositiveNumber.optional(),
+    astralTokensPerChar: decidePositiveNumber.optional(),
+    models: z
+        .record(z.string(), z.strictObject({
+        maxStateTokens: decidePositiveInt,
+        nonAsciiTokensPerChar: decidePositiveNumber.optional(),
+    }))
+        .optional(),
+    advisory: z.boolean().optional(),
+});
+const decideCatalogJsonSchema = z
+    .strictObject({
+    ...catalogIdentityShape,
+    inferenceKinds: z.tuple([z.literal("decide")]),
+    tier: z.literal(2).optional(),
+    wire: decideWireSchema,
+    models: decideModelsSchema,
+    timeouts: z
+        .strictObject({ decideMs: decidePositiveInt.optional() })
+        .optional(),
+    decisionLimits: decideLimitsSchema.optional(),
+    decide: decideBlockSchema,
+    setup: catalogSetupSchema,
+    evidence: catalogEvidenceSchema,
+})
+    .superRefine((entry, ctx) => {
+    const { wire, decide } = entry;
+    const issue = (path, message) => {
+        ctx.addIssue({ code: "custom", path, message });
+    };
+    const seenStatus = new Set();
+    const seenStatusMin = new Set();
+    decide.errors.rules.forEach((rule, index) => {
+        const at = ["decide", "errors", "rules", index];
+        if ((rule.status === undefined) === (rule.statusMin === undefined)) {
+            issue(at, "errors.rules entry needs exactly one of status or statusMin");
+        }
+        const statuses = typeof rule.status === "number" ? [rule.status] : (rule.status ?? []);
+        for (const status of statuses) {
+            if (seenStatus.has(status)) {
+                issue([...at, "status"], `errors.rules lists status ${status} more than once`);
+            }
+            seenStatus.add(status);
+        }
+        if (rule.statusMin !== undefined) {
+            if (seenStatusMin.has(rule.statusMin)) {
+                issue([...at, "statusMin"], `errors.rules lists statusMin ${rule.statusMin} more than once`);
+            }
+            seenStatusMin.add(rule.statusMin);
+        }
+    });
+    const modelKeys = new Set(Object.keys(entry.models.catalog));
+    if (!modelKeys.has(entry.models.default)) {
+        issue(["models", "default"], "models.default must be a key of models.catalog");
+    }
+    const seenTopModels = new Set();
+    (entry.models.topModels ?? []).forEach((id, index) => {
+        if (!modelKeys.has(id)) {
+            issue(["models", "topModels", index], "models.topModels entry must be a key of models.catalog");
+        }
+        if (seenTopModels.has(id)) {
+            issue(["models", "topModels", index], "models.topModels must not contain duplicate entries");
+        }
+        seenTopModels.add(id);
+    });
+    const { alias, placement } = decide.model;
+    if (placement === "body-unless-alias" && alias === undefined) {
+        issue(["decide", "model", "alias"], "decide.model.alias is required when placement is body-unless-alias");
+    }
+    if (placement === "body" && alias !== undefined) {
+        issue(["decide", "model", "alias"], "decide.model.alias is only valid with placement body-unless-alias");
+    }
+    if (alias !== undefined && !modelKeys.has(alias)) {
+        issue(["decide", "model", "alias"], "decide.model.alias must be a key of models.catalog");
+    }
+    for (const id of Object.keys(entry.decisionLimits?.models ?? {})) {
+        if (!modelKeys.has(id)) {
+            issue(["decisionLimits", "models", id], "decisionLimits.models key must be a key of models.catalog");
+        }
+    }
+    if (decide.baseURLRequired === true &&
+        !decide.endpoint.includes("{baseURL}")) {
+        issue(["decide", "endpoint"], "decide.endpoint must contain {baseURL} when decide.baseURLRequired is true");
+    }
+    const seenShapes = new Set();
+    decide.errors.bodyShapes.forEach((shape, index) => {
+        const key = `${shape.path}|${shape.isArray === true}`;
+        if (seenShapes.has(key)) {
+            issue(["decide", "errors", "bodyShapes", index], "errors.bodyShapes lists the same path and isArray twice");
+        }
+        seenShapes.add(key);
+    });
+    const seenHeaders = new Set();
+    (decide.requestIdHeaders ?? []).forEach((header, index) => {
+        if (seenHeaders.has(header.toLowerCase())) {
+            issue(["decide", "requestIdHeaders", index], "requestIdHeaders lists the same header twice; header names are case-insensitive");
+        }
+        seenHeaders.add(header.toLowerCase());
+    });
+    for (const key of UNSUPPORTED_DECIDE_WIRE_KEYS) {
+        if (wire[key] !== undefined) {
+            issue(["wire", key], `wire.${key} is not supported on decide entries yet; ConfiguredDecisionProvider does not read it`);
+        }
+    }
+    const hasBaseURL = wire.baseURL !== undefined;
+    const hasTemplate = wire.baseURLTemplate !== undefined;
+    if (decide.baseURLRequired === true) {
+        if (hasBaseURL || hasTemplate) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["wire", hasBaseURL ? "baseURL" : "baseURLTemplate"],
+                message: "wire must not set baseURL or baseURLTemplate when decide.baseURLRequired is true; the caller supplies the base URL",
+            });
+        }
+    }
+    else if (hasBaseURL === hasTemplate) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["wire", "baseURL"],
+            message: "wire requires exactly one of baseURL or baseURLTemplate unless decide.baseURLRequired is true",
+        });
+    }
+});
+function describeIssues(error) {
+    return error.issues
+        .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+        .join("; ");
+}
+function carriesInferenceKinds(raw) {
+    return (typeof raw === "object" &&
+        raw !== null &&
+        raw.inferenceKinds !== undefined);
+}
+export function parseCatalogEntry(raw, sourcePath = "<in-memory entry>") {
+    if (!carriesInferenceKinds(raw)) {
+        return parseProviderCatalogJson(raw, sourcePath);
+    }
+    const result = decideCatalogJsonSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid decide catalog file ${sourcePath}: ${describeIssues(result.error)}`);
+    }
+    return result.data;
+}
+export function isDecideCatalogEntry(entry) {
+    return "inferenceKinds" in entry;
+}
 export function parseProviderCatalogJson(raw, sourcePath) {
+    if (carriesInferenceKinds(raw)) {
+        throw new Error(`Invalid provider catalog file ${sourcePath}: inferenceKinds is set, so this is a decide entry; parse it with parseCatalogEntry`);
+    }
     const result = providerCatalogJsonSchema.safeParse(raw);
     if (!result.success) {
         throw new Error(`Invalid provider catalog file ${sourcePath}: ${result.error.issues

package/dist/providers/configuredDecision.d.ts

@@ -0,0 +1,23 @@
+import type { DecideCatalogJson, DecisionDialect, DecisionError, 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 {
+    private readonly entry;
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly endpoint;
+    constructor(entry: DecideCatalogJson, modelName?: string, sdk?: unknown, credentials?: UnknownRecord);
+    protected getDefaultModel(): string;
+    protected vendorLabel(): string;
+    protected vendorDisplayName(): string;
+    protected decisionApiKey(): string;
+    protected missingKeyMessage(): string;
+    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 parseDecisionError(status: number, payload: unknown, requestId: string | undefined): DecisionError;
+    protected readRequestId(headers: Headers): string | undefined;
+    protected resolveResponseModel(payload: Record<string, unknown>, requestedModel: string): string;
+    protected dialect(): DecisionDialect;
+}

package/dist/providers/configuredDecision.js

@@ -0,0 +1,111 @@
+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 { getDecisionDialect } from "./decide/dialects/index.js";
+import { classifyDecisionError } from "./decide/errors.js";
+import { isRecord } from "./decide/guards.js";
+import { readPath } from "./decide/paths.js";
+import { fillEndpointTemplate } from "./decide/template.js";
+import { SystemOneDecisionProvider } from "./systemOneDecision.js";
+const readText = (value) => typeof value === "string" ? value.trim() : "";
+/** A `decide` provider described entirely by its catalog entry. */
+export class ConfiguredDecisionProvider extends SystemOneDecisionProvider {
+    entry;
+    apiKey;
+    baseURL;
+    endpoint;
+    constructor(entry, modelName, sdk, credentials) {
+        // BaseProvider's constructor calls getDefaultModel() for a falsy name,
+        // before this.entry is assigned, so the name is settled here.
+        super(modelName ||
+            getProviderModel(catalogEnvVar(entry, "model"), entry.models.default), entry.id, sdk);
+        this.entry = entry;
+        this.apiKey =
+            readText(credentials?.apiKey) ||
+                readText(process.env[catalogEnvVar(entry, "apiKey")]);
+        // `||`, not `??`, so a blank value counts as unset.
+        this.baseURL = normalizeBaseURL(readText(credentials?.baseURL) ||
+            readText(process.env[catalogEnvVar(entry, "baseURL")]) ||
+            readText(entry.wire.baseURL), entry.decide.baseURLNormalize ?? []);
+        this.endpoint = fillEndpointTemplate(entry.decide.endpoint, {
+            baseURL: this.baseURL,
+        });
+        // A self-hosted base URL can carry `user:pass@` or a `?token=`.
+        logger.debug(`${entry.displayName} Provider initialized (decide only)`, {
+            modelName: this.modelName,
+            baseURL: this.baseURL ? redactUrlForError(this.baseURL) : "(not set)",
+        });
+    }
+    getDefaultModel() {
+        return getProviderModel(catalogEnvVar(this.entry, "model"), this.entry.models.default);
+    }
+    vendorLabel() {
+        return this.entry.displayName;
+    }
+    vendorDisplayName() {
+        return this.entry.displayName;
+    }
+    decisionApiKey() {
+        return this.apiKey;
+    }
+    missingKeyMessage() {
+        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.`
+            : undefined;
+    }
+    decisionEndpoint() {
+        return this.endpoint;
+    }
+    decisionHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    buildDecisionBody(state, questions, model) {
+        const { placement, alias } = this.entry.decide.model;
+        return placement === "body-unless-alias" && model === alias
+            ? { state, questions }
+            : { model, state, questions };
+    }
+    parseDecisionError(status, payload, requestId) {
+        return classifyDecisionError(this.entry.decide.errors, {
+            status,
+            payload,
+            requestId,
+            label: this.entry.displayName,
+            apiKey: this.apiKey,
+        });
+    }
+    readRequestId(headers) {
+        for (const name of this.entry.decide.requestIdHeaders ?? []) {
+            const value = headers.get(name);
+            if (value !== null) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    resolveResponseModel(payload, requestedModel) {
+        // Defensive: the base class passes a record today. A direct call with
+        // null or undefined must not throw here, where the base lookup would.
+        if (!isRecord(payload)) {
+            return requestedModel;
+        }
+        for (const path of this.entry.decide.response?.modelPaths ?? []) {
+            const value = readPath(payload, path);
+            if (typeof value === "string") {
+                return value;
+            }
+        }
+        return super.resolveResponseModel(payload, requestedModel);
+    }
+    dialect() {
+        return getDecisionDialect(this.entry.decide.dialect);
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { DecideBaseURLTransform } from "../../types/index.js";
+export declare function normalizeBaseURL(raw: string, transforms: readonly DecideBaseURLTransform[]): string;

package/dist/providers/decide/baseUrl.js

@@ -0,0 +1,14 @@
+const TRANSFORMS = {
+    // A loop, not /\/+$/: that pattern is quadratic on a long run of slashes
+    // followed by another character.
+    "strip-trailing-slash": (value) => {
+        let end = value.length;
+        while (end > 0 && value[end - 1] === "/") {
+            end -= 1;
+        }
+        return value.slice(0, end);
+    },
+};
+export function normalizeBaseURL(raw, transforms) {
+    return transforms.reduce((value, name) => TRANSFORMS[name](value), raw);
+}

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

@@ -0,0 +1,8 @@
+import type { DecideErrors, DecisionError } from "../../types/index.js";
+export declare function classifyDecisionError(spec: DecideErrors, input: {
+    status: number;
+    payload: unknown;
+    requestId: string | undefined;
+    label: string;
+    apiKey: string;
+}): DecisionError;

package/dist/providers/decide/errors.js

@@ -0,0 +1,57 @@
+import { redactCredentials } from "../systemOneDecision.js";
+import { DECIDE_FORMATTERS } from "./formatters.js";
+import { readPath } from "./paths.js";
+const RETRYABLE_BY_DEFAULT = new Set([
+    "rate_limit",
+    "overloaded",
+    "server",
+]);
+const isRetryableByDefault = (kind) => RETRYABLE_BY_DEFAULT.has(kind);
+function ruleMatches(rule, status) {
+    const statuses = rule.status === undefined
+        ? []
+        : typeof rule.status === "number"
+            ? [rule.status]
+            : rule.status;
+    return (statuses.includes(status) ||
+        (rule.statusMin !== undefined && status >= rule.statusMin));
+}
+function messageFromShape(shape, value) {
+    if (shape.isArray) {
+        return Array.isArray(value) && shape.formatter
+            ? DECIDE_FORMATTERS[shape.formatter](value)
+            : undefined;
+    }
+    if (typeof value !== "string" || value.length === 0) {
+        return undefined;
+    }
+    return shape.formatter ? DECIDE_FORMATTERS[shape.formatter](value) : value;
+}
+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) => ({
+        kind,
+        message: (text && redactCredentials(text, apiKey)) || fallback,
+        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);
+        }
+    }
+    return build(ruleKind, ruleRetryable);
+}

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

@@ -0,0 +1,2 @@
+import type { DecideFormatterName } from "../../types/index.js";
+export declare const DECIDE_FORMATTERS: Readonly<Record<DecideFormatterName, (detail: unknown) => string>>;

package/dist/providers/decide/formatters.js

@@ -0,0 +1,4 @@
+import { describeValidationErrors } from "../systemOneDecision.js";
+export const DECIDE_FORMATTERS = {
+    "fastapi-validation": (detail) => `Request failed validation — ${describeValidationErrors(Array.isArray(detail) ? detail : [])}`,
+};

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

@@ -0,0 +1 @@
+export declare function readPath(value: unknown, path: string): unknown;