@juspay/neurolink 13.4.10 → 13.5.0

package/dist/providers/decide/dialects/openaiDecisions.js

@@ -30,6 +30,11 @@ function encodeQuestion(question) {
             })),
         };
     }
+    if (question.type === "value") {
+        // Unreachable through decide(): an entry on this dialect cannot list
+        // `value` in its questionTypes, so the pre-flight check refuses it first.
+        throw new Error("The openai-decisions dialect has no value question; it writes boolean, choice and score questions only.");
+    }
     // The index is the label so a returned `value` and `label` can never
     // disagree about which level it is; the rubric text rides in `description`.
     return {
@@ -140,6 +145,9 @@ function readAnswer(question, raw) {
     if (question.type === "choice") {
         return raw.type === "choice" ? readChoice(question, raw) : null;
     }
+    if (question.type === "value") {
+        return null;
+    }
     return raw.type === "score" ? readScore(question, raw) : null;
 }
 /** Number of answers carrying each asked name, so a repeated one can be refused. */

package/dist/providers/decide/dialects/systemOne.js

@@ -1,4 +1,4 @@
-import { asNumber, asNumberMap, asStringMap, isRecord } from "../guards.js";
+import { asNumber, asNumberMap, asTextMap, isRecord } from "../guards.js";
 /**
  * Last-resort confidence, when no transport reported one.
  *
@@ -43,11 +43,12 @@ function parseDecisionAnswer(raw, reportedConfidence) {
                     reportedConfidence ??
                     deriveConfidence(probabilities),
                 probabilities,
+                ...(raw.unknown === true ? { unknown: true } : {}),
             };
         }
         case "score": {
             const score = asNumber(raw.score);
-            const legend = asStringMap(raw.legend);
+            const legend = asTextMap(raw.legend);
             const probabilities = asNumberMap(raw.probabilities);
             if (score === undefined || !legend || !probabilities) {
                 return null;
@@ -62,6 +63,21 @@ function parseDecisionAnswer(raw, reportedConfidence) {
                 probabilities,
             };
         }
+        case "value": {
+            const value = raw.value === null || typeof raw.value === "string"
+                ? raw.value
+                : asNumber(raw.value);
+            const confidence = asNumber(raw.confidence) ?? reportedConfidence;
+            if (value === undefined || confidence === undefined) {
+                return null;
+            }
+            return {
+                type: "value",
+                value,
+                confidence,
+                ...(raw.unknown === true ? { unknown: true } : {}),
+            };
+        }
         default:
             return null;
     }
@@ -78,6 +94,13 @@ function encodeQuestion(question) {
             ...(question.criteria ? { criteria: question.criteria } : {}),
         };
     }
+    if (question.type === "choice" && question.unknown !== undefined) {
+        // `unknown` goes out only when it is on: a server that does not know the
+        // field may refuse it even as false. A choice without it is the caller's
+        // own object, as every other question is.
+        const { unknown, ...rest } = question;
+        return unknown ? { ...rest, unknown: true } : rest;
+    }
     return question;
 }
 export const systemOneDialect = {
@@ -98,6 +121,9 @@ export const systemOneDialect = {
             ...(media.video && mediaKeys.videoKey
                 ? { [mediaKeys.videoKey]: media.video }
                 : {}),
+            ...(media.audio && mediaKeys.audioKey
+                ? { [mediaKeys.audioKey]: media.audio }
+                : {}),
         };
     },
     readAnswers: (decoded, reportedConfidence) => {

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

@@ -2,3 +2,9 @@ export declare const isRecord: (v: unknown) => v is Record<string, unknown>;
 export declare const asNumber: (v: unknown) => number | undefined;
 export declare const asNumberMap: (v: unknown) => Record<string, number> | undefined;
 export declare const asStringMap: (v: unknown) => Record<string, string> | undefined;
+/**
+ * A map whose values are shown as text: a string as is, anything else a JSON
+ * value can hold as its JSON text. A score legend echoes each level as the
+ * caller gave it, and a level may be a number or an object.
+ */
+export declare const asTextMap: (v: unknown) => Record<string, string> | undefined;

package/dist/providers/decide/guards.js

@@ -27,3 +27,25 @@ export const asStringMap = (v) => {
     }
     return out;
 };
+/**
+ * A map whose values are shown as text: a string as is, anything else a JSON
+ * value can hold as its JSON text. A score legend echoes each level as the
+ * caller gave it, and a level may be a number or an object.
+ */
+export const asTextMap = (v) => {
+    if (!isRecord(v)) {
+        return undefined;
+    }
+    const out = {};
+    for (const [k, raw] of Object.entries(v)) {
+        if (typeof raw === "string") {
+            out[k] = raw;
+            continue;
+        }
+        if (raw === undefined || typeof raw === "function") {
+            return undefined;
+        }
+        out[k] = JSON.stringify(raw);
+    }
+    return out;
+};

package/dist/providers/systemOneDecision.d.ts

@@ -22,6 +22,12 @@ export declare function describeValidationErrors(detail: readonly unknown[]): st
  * belongs in an error message or a log, whatever the wording, so the
  * configured key, anything shaped like a LiteLLM key, any long hex run and any
  * embedded `data:` URL are all removed.
+ *
+ * Its request-validation errors also quote the request back (pydantic's
+ * `input_value=…`, the start of the state and questions), and its routing
+ * errors append the gateway's fallback table, which names every model group it
+ * serves. The first is the caller's data and the second is the gateway's, so
+ * both are cut.
  */
 export declare function redactCredentials(message: string, apiKey: string): string;
 /**
@@ -85,12 +91,14 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      */
     protected readRetryAfterMs(_headers: Headers): number | undefined;
     /**
-     * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions or the size of the state scales the
-     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
-     * descriptor sets no local limits.
+     * The per-attempt timeout when the caller sets none: the descriptor's
+     * `decideMs`, plus `decideMsPerKStateTokens` for every full 1,000 estimated
+     * state tokens when it declares that, since a long state takes longer to read
+     * and a flat budget would cut off a request well inside the model's window. A
+     * provider whose latency grows another way overrides this. `stateTokens` is
+     * the local estimate, 0 when the descriptor sets no local limits.
      */
-    protected defaultTimeoutMs(_questionCount: number, _stateTokens: number): number | undefined;
+    protected defaultTimeoutMs(_questionCount: number, stateTokens: number): number | undefined;
     /**
      * The part of a successful response that holds `answers`, `usage` and
      * `model`. The default is the response itself; a vendor that wraps every
@@ -101,6 +109,12 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
     /** Per-question confidence a transport reports outside the answer objects. */
     protected reportedConfidence(_payload: unknown): Record<string, number>;
     protected resolveResponseModel(payload: Record<string, unknown>, requestedModel: string): string;
+    /**
+     * The model this request goes to and is checked against: the call's own, else
+     * the instance's. A provider whose default cannot read some requests may pick
+     * another for them here.
+     */
+    protected resolveRequestModel(request: DecisionRequest): string;
     /** Extra fields for the credential-rejected warning. */
     protected diagnosticContext(): Record<string, unknown>;
     protected getProviderName(): AIProviderName;
@@ -126,8 +140,17 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      */
     decide(request: DecisionRequest): Promise<DecisionResult>;
     /**
-     * Turn the request's images and video into data URLs, or refuse it. Refused
-     * as a non-retryable `invalid_request`: resending the same media cannot help.
+     * Refuse a question this provider does not read: a type it does not list in
+     * `decisionLimits.questionTypes` (absent means boolean, choice and score), or
+     * a choice or score past its per-question cap. Checked even when the limits
+     * are advisory, since a server that does not know a question type cannot
+     * answer it.
+     */
+    private assertSupportedQuestions;
+    /**
+     * Turn the request's images, video and audio into wire form, or refuse it.
+     * Refused as a non-retryable `invalid_request`: resending the same media
+     * cannot help.
      */
     private prepareMedia;
     /**

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 { estimateDecisionStateTokens, resolveDecisionLimitsReading, } from "../utils/decisionLimits.js";
+import { estimateDecisionStateTokens, resolveDecisionLimitsReading, unsupportedDecisionQuestion, } from "../utils/decisionLimits.js";
 import { systemOneDialect } from "./decide/dialects/systemOne.js";
 import { asNumber, isRecord } from "./decide/guards.js";
 /**
@@ -44,17 +44,31 @@ export function describeValidationErrors(detail) {
  * belongs in an error message or a log, whatever the wording, so the
  * configured key, anything shaped like a LiteLLM key, any long hex run and any
  * embedded `data:` URL are all removed.
+ *
+ * Its request-validation errors also quote the request back (pydantic's
+ * `input_value=…`, the start of the state and questions), and its routing
+ * errors append the gateway's fallback table, which names every model group it
+ * serves. The first is the caller's data and the second is the gateway's, so
+ * both are cut.
  */
 export function redactCredentials(message, apiKey) {
     const withoutKey = apiKey
         ? message.split(apiKey).join("[redacted]")
         : message;
-    return withoutKey
+    return (withoutKey
         .replace(/\.?\s*Received API Key\s*=[\s\S]*$/, "")
+        .replace(/\.?\s*Received Model Group=[\s\S]*$/, "")
+        .replace(/\s*No fallback model group found[\s\S]*$/, "")
+        // Greedy: the quoted value may itself contain ", input_type=", so only the
+        // last one is a delimiter the server wrote.
+        .replace(/input_value=[\s\S]*(?=, input_type=)/g, "input_value=[redacted]")
+        // Cut short by the server, a quoted value has no input_type after it, and
+        // may run over several lines; everything after it is the value.
+        .replace(/input_value=(?!\[redacted\])[\s\S]*/g, "input_value=[redacted]")
         .replace(/\bsk-[A-Za-z0-9._-]+/g, "[redacted]")
         .replace(/\b[0-9a-f]{32,}\b/gi, "[redacted]")
         .replace(/data:[a-z]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "[media]")
-        .trim();
+        .trim());
 }
 /**
  * Whether a failed `fetch` was one that refused a redirect. undici words every
@@ -151,13 +165,20 @@ export class SystemOneDecisionProvider extends BaseProvider {
         return undefined;
     }
     /**
-     * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions or the size of the state scales the
-     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
-     * descriptor sets no local limits.
+     * The per-attempt timeout when the caller sets none: the descriptor's
+     * `decideMs`, plus `decideMsPerKStateTokens` for every full 1,000 estimated
+     * state tokens when it declares that, since a long state takes longer to read
+     * and a flat budget would cut off a request well inside the model's window. A
+     * provider whose latency grows another way overrides this. `stateTokens` is
+     * the local estimate, 0 when the descriptor sets no local limits.
      */
-    defaultTimeoutMs(_questionCount, _stateTokens) {
-        return this.getDescriptorDecideMs();
+    defaultTimeoutMs(_questionCount, stateTokens) {
+        const base = this.getDescriptorDecideMs();
+        const perK = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts
+            ?.decideMsPerKStateTokens;
+        return base === undefined || perK === undefined
+            ? base
+            : base + Math.floor(stateTokens / 1000) * perK;
     }
     /**
      * The part of a successful response that holds `answers`, `usage` and
@@ -175,6 +196,14 @@ export class SystemOneDecisionProvider extends BaseProvider {
     resolveResponseModel(payload, requestedModel) {
         return typeof payload.model === "string" ? payload.model : requestedModel;
     }
+    /**
+     * The model this request goes to and is checked against: the call's own, else
+     * the instance's. A provider whose default cannot read some requests may pick
+     * another for them here.
+     */
+    resolveRequestModel(request) {
+        return request.model ?? this.modelName ?? this.getDefaultModel();
+    }
     /** Extra fields for the credential-rejected warning. */
     diagnosticContext() {
         return {};
@@ -250,7 +279,8 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 retryable: false,
             });
         }
-        const resolvedModel = request.model ?? this.modelName ?? this.getDefaultModel();
+        const resolvedModel = this.resolveRequestModel(request);
+        this.assertSupportedQuestions(request, resolvedModel);
         const stateTokens = this.assertWithinDecisionLimits(request, resolvedModel, questionEntries.length);
         const wireQuestions = Object.fromEntries(questionEntries.map(([id, question]) => [
             id,
@@ -393,12 +423,39 @@ export class SystemOneDecisionProvider extends BaseProvider {
         });
     }
     /**
-     * Turn the request's images and video into data URLs, or refuse it. Refused
-     * as a non-retryable `invalid_request`: resending the same media cannot help.
+     * Refuse a question this provider does not read: a type it does not list in
+     * `decisionLimits.questionTypes` (absent means boolean, choice and score), or
+     * a choice or score past its per-question cap. Checked even when the limits
+     * are advisory, since a server that does not know a question type cannot
+     * answer it.
+     */
+    assertSupportedQuestions(request, model) {
+        const descriptor = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName);
+        const limits = descriptor
+            ? resolveDecisionLimitsReading(descriptor, model)
+            : null;
+        for (const [id, question] of Object.entries(request.questions)) {
+            const problem = unsupportedDecisionQuestion(question, limits);
+            if (problem !== undefined) {
+                throw this.decisionError({
+                    kind: "invalid_request",
+                    message: `${this.vendorLabel()} cannot answer question "${id}": ${problem}.`,
+                    retryable: false,
+                });
+            }
+        }
+    }
+    /**
+     * Turn the request's images, video and audio into wire form, or refuse it.
+     * Refused as a non-retryable `invalid_request`: resending the same media
+     * cannot help.
      */
     async prepareMedia(request) {
         const limits = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.decisionLimits;
-        const prepared = await prepareDecisionMedia(request, limits?.media, this.vendorLabel(), listMediaDecisionProviders({ video: request.video !== undefined }));
+        const prepared = await prepareDecisionMedia(request, limits?.media, this.vendorLabel(), listMediaDecisionProviders({
+            video: request.video !== undefined,
+            audio: request.audio !== undefined,
+        }));
         if (prepared.status === "refused") {
             throw this.decisionError({
                 kind: "invalid_request",
@@ -423,7 +480,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${media?.video ? ", 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" : ""}${media?.audio ? ", or a shorter audio clip" : ""}.`,
                 retryable: false,
             });
         }

package/dist/types/cli.d.ts

@@ -1312,6 +1312,8 @@ export type CliDecideArgs = {
     image?: string[];
     /** One video file (or data: URL) for a provider that reads video. */
     video?: string;
+    /** One audio file (or data: URL) for a provider that reads audio. */
+    audio?: string;
     provider?: string;
     model?: string;
     timeout?: number;

package/dist/types/decision.d.ts

@@ -53,6 +53,13 @@ export type DecisionChoiceQuestion = {
     type: "choice";
     instructions: DecisionInput;
     criteria: Readonly<Record<string, DecisionInput | null>>;
+    /**
+     * True adds an option named `unknown` the model picks when none of the
+     * criteria fits; the answer then carries `unknown: true`. Only a provider
+     * whose `decisionLimits.questionTypes` lists `"choice-unknown"` accepts it,
+     * and no criteria key may be named `unknown` alongside it.
+     */
+    unknown?: boolean;
 };
 /**
  * Rate against an ordered rubric. The answer is the **0-based index**, so a
@@ -63,7 +70,24 @@ export type DecisionScoreQuestion = {
     instructions: DecisionInput;
     criteria: readonly (DecisionInput | null)[];
 };
-export type DecisionQuestion = DecisionBooleanQuestion | DecisionChoiceQuestion | DecisionScoreQuestion;
+/**
+ * Extract one typed field from the state: an amount, a reference, a name. Only
+ * a provider whose `decisionLimits.questionTypes` lists `"value"` accepts it.
+ */
+export type DecisionValueQuestion = {
+    type: "value";
+    instructions: DecisionInput;
+    /** The type of the extracted value. Omitted means `string`. */
+    dtype?: "string" | "int" | "float";
+    /** A regular expression the extracted text must match. */
+    pattern?: string;
+};
+export type DecisionQuestion = DecisionBooleanQuestion | DecisionChoiceQuestion | DecisionScoreQuestion | DecisionValueQuestion;
+/**
+ * What a provider may be asked, per question. `"choice-unknown"` is a `choice`
+ * question that sets `unknown: true`.
+ */
+export type DecisionQuestionType = DecisionQuestion["type"] | "choice-unknown";
 /** Questions keyed by an id you choose; answers return under the same ids. */
 export type DecisionQuestionMap = Readonly<Record<string, DecisionQuestion>>;
 export type DecisionBooleanAnswer = {
@@ -79,24 +103,34 @@ export type DecisionChoiceAnswer = {
     probabilities: Readonly<Record<string, number>>;
     /** Calibrated certainty, 0–1, derived from the distribution. */
     confidence: number;
+    /** True when the question set `unknown` and the model picked it. */
+    unknown?: boolean;
 };
 export type DecisionScoreAnswer = {
     type: "score";
     /** Probability-weighted level index; lands between levels. */
     score: number;
-    /** Level index (as a string key) → the description supplied. */
+    /** Level index (as a string key) → the description supplied; a level that was not a string is given as its JSON text. */
     legend: Readonly<Record<string, string>>;
     /** Level index (as a string key) → probability. */
     probabilities: Readonly<Record<string, number>>;
     confidence: number;
 };
-export type DecisionAnswer = DecisionBooleanAnswer | DecisionChoiceAnswer | DecisionScoreAnswer;
+export type DecisionValueAnswer = {
+    type: "value";
+    /** The extracted value: a number for `int` / `float`, else a string. Null when the model abstained. */
+    value: string | number | null;
+    confidence: number;
+    /** True when the model found nothing to extract; `value` is then null. */
+    unknown?: boolean;
+};
+export type DecisionAnswer = DecisionBooleanAnswer | DecisionChoiceAnswer | DecisionScoreAnswer | DecisionValueAnswer;
 export type DecisionAnswerMap = Readonly<Record<string, DecisionAnswer>>;
 export type DecisionUsage = {
     inputTokens: number;
     outputTokens: number;
 };
-/** An image or video as the caller supplies it: raw bytes, a file path, or a data URL. */
+/** An image, video or audio clip as the caller supplies it: raw bytes, a file path, or a data URL. */
 export type DecisionMediaSource = Buffer | string;
 export type DecisionRequest = {
     state: DecisionState;
@@ -109,6 +143,11 @@ export type DecisionRequest = {
     images?: readonly DecisionMediaSource[];
     /** One video, in the same forms. Sending images as well is allowed. */
     video?: DecisionMediaSource;
+    /**
+     * One audio clip, in the same forms (a `data:audio/…;base64,` URL). Only a
+     * provider whose `decisionLimits.media.audio` is set accepts it.
+     */
+    audio?: DecisionMediaSource;
     /** Overrides the provider's configured model for this call only. */
     model?: string;
     signal?: AbortSignal;
@@ -127,7 +166,7 @@ export type DecisionResult = {
     latencyMs: number;
     /** Server-side time behind the edge; isolates model time from network. */
     upstreamMs?: number;
-    /** Encoded size of the images and video sent. Absent for a text-only request. */
+    /** Encoded size of the images, video and audio sent. Absent for a text-only request. */
     mediaBytes?: number;
 };
 /**
@@ -147,6 +186,16 @@ export type DecisionLimits = {
     maxStateTokens: number;
     /** Absent when the provider has no cap on questions per request. */
     maxQuestions?: number;
+    /**
+     * The question types the provider reads. Absent means `boolean`, `choice`
+     * and `score`; a request asking anything else is refused before any network
+     * call, whether or not the limits are advisory.
+     */
+    questionTypes?: readonly DecisionQuestionType[];
+    /** Most levels one `score` question may have. Absent means no local cap. */
+    maxScoreLevels?: number;
+    /** Most options one `choice` question may have. Absent means no local cap. */
+    maxChoiceOptions?: number;
     /**
      * Tokens charged per non-ASCII character. The default estimate assumes ~4
      * characters per token, which holds for English and is several times too
@@ -208,9 +257,15 @@ export type DecisionLimitsReading = {
     maxStateTokens: number;
     /**
      * Absent when the provider caps a request by tokens (or bytes) rather
-     * than by question count — TypeSafe and XOR; `Infinity` is never used.
+     * than by question count — TypeSafe; `Infinity` is never used.
      */
     maxQuestions?: number;
+    /** Present only when the descriptor declares it; absent means `boolean`, `choice` and `score`. */
+    questionTypes?: readonly DecisionQuestionType[];
+    /** Most levels one `score` question may have; absent means no local cap. */
+    maxScoreLevels?: number;
+    /** Most options one `choice` question may have; absent means no local cap. */
+    maxChoiceOptions?: number;
     nonAsciiTokensPerChar?: number;
     /** Tokens charged per ASCII digit; see {@link DecisionLimits.digitTokensPerChar}. */
     digitTokensPerChar?: number;
@@ -241,19 +296,36 @@ export type DecisionMediaLimits = {
     video: boolean;
     /** Ceiling on the encoded request body, in bytes. */
     maxRequestBytes: number;
+    /** Whether one audio clip is accepted, and how much of it the model hears. Absent means no audio. */
+    audio?: DecisionAudioLimits;
+};
+export type DecisionAudioLimits = {
+    /**
+     * Seconds of audio the model reads. A clip whose length can be read from its
+     * header (WAV, FLAC, Ogg) and runs longer is refused, since the rest would be cut
+     * off without a word.
+     */
+    maxSeconds: number;
 };
 /** An image's size in pixels, read from its header. */
 export type DecisionImageDimensions = {
     width: number;
     height: number;
 };
-/** Media after preparation: everything is a `data:` URL, ready for the wire. */
+/** Media after preparation: images and video are `data:` URLs, ready for the wire. */
 export type DecisionPreparedMedia = {
     images: string[];
     video?: string;
-    /** Encoded size of every URL above. */
+    audio?: DecisionPreparedAudio;
+    /** Encoded size of everything above. */
     bytes: number;
 };
+/** An audio clip as the wire takes it: raw base64 and the container it was sniffed as. */
+export type DecisionPreparedAudio = {
+    data: string;
+    format: DecisionAudioFormat;
+};
+export type DecisionAudioFormat = "wav" | "flac" | "ogg" | "mp3";
 /**
  * Discriminated by a string literal, not a boolean: the package is also
  * compiled without strictNullChecks, where a boolean discriminant does not
@@ -266,8 +338,8 @@ export type DecisionMediaResult = {
     status: "refused";
     message: string;
 };
-export type DecisionMediaKind = "image" | "video";
-/** One image or video turned into a data URL, or the reason it could not be. Same literal-discriminant rule as above. */
+export type DecisionMediaKind = "image" | "video" | "audio";
+/** One image, video or audio clip turned into a data URL, or the reason it could not be. Same literal-discriminant rule as above. */
 export type DecisionMediaConversion = {
     status: "ok";
     dataUrl: string;
@@ -283,6 +355,21 @@ export type DecisionMediaFileRead = {
     status: "error";
     message: string;
 };
+/**
+ * A caller's media source resolved for one kind: bytes to identify (a Buffer
+ * or a file read from disk), a `data:` URL of that kind as given, or the reason
+ * it is refused.
+ */
+export type DecisionMediaSourceRead = {
+    status: "buffer";
+    buffer: Buffer;
+} | {
+    status: "dataUrl";
+    dataUrl: string;
+} | {
+    status: "error";
+    message: string;
+};
 /**
  * Why a decision call failed, normalised across vendors. TypeSafe alone
  * returns two different error envelopes, so a provider must flatten them.
@@ -318,6 +405,11 @@ export type DecisionChoiceReading = {
         name: string;
         probability: number;
     }[];
+    /**
+     * True when the question set `unknown` and the model picked it: `choice` is
+     * then `"unknown"`, which is none of the question's own options.
+     */
+    unknown: boolean;
 };
 export type DecisionScoreReading = {
     score: number;
@@ -325,6 +417,12 @@ export type DecisionScoreReading = {
     legend: Readonly<Record<string, string>>;
     probabilities: Readonly<Record<string, number>>;
 };
+export type DecisionValueReading = {
+    value: string | number | null;
+    confidence: number;
+    /** True when the model abstained; `value` is then null. */
+    unknown: boolean;
+};
 /**
  * What `NeuroLink.decide()` accepts: a decision request plus the usual
  * provider/credential selection every inference type shares.
@@ -543,6 +641,8 @@ export type DecideMedia = {
     imagesKey: string;
     /** Written only when the request carries a video; required exactly when `decisionLimits.media.video` is true. */
     videoKey?: string;
+    /** Written only when the request carries audio, as `{ data, format }`; required exactly when `decisionLimits.media.audio` is set. */
+    audioKey?: string;
 };
 /**
  * Says when a decide provider's key may be used as the default decision
@@ -580,6 +680,13 @@ export type DecideAmbientKeyCredentialField = {
     /** The field in that slice. Only `baseURL` is read today. */
     field: "baseURL";
 };
+/** See `DecideBlock.capableModel`. */
+export type DecideCapableModel = {
+    /** A key of the entry's `models.catalog`. */
+    model: string;
+    /** Question types that send a request to `model`; media always does. */
+    questionTypes: readonly DecisionQuestionType[];
+};
 /** What a dialect lays out as one request body. */
 export type DecisionDialectBody = {
     readonly state: DecisionState;

package/dist/types/providerCatalog.d.ts

@@ -4,7 +4,7 @@
  * src/lib/providers/catalog/<id>.json file per provider is the single
  * source of truth; see docs/superpowers/plans/2026-08-28-provider-json-catalog-spec.md.
  */
-import type { DecideAmbientKeyGuard, DecideDialectName, DecideMedia, DecisionErrorKind, DecisionLimits } from "./decision.js";
+import type { DecideAmbientKeyGuard, DecideCapableModel, DecideDialectName, DecideMedia, DecisionErrorKind, DecisionLimits } from "./decision.js";
 export type CatalogPricingPerMTok = {
     input: number;
     output: number;
@@ -338,6 +338,15 @@ export type DecideBlock = {
     stateEncoding?: "text";
     /** Body keys for images and video, after `model`, `state` and `questions`. Omitted means the body never carries media. */
     media?: DecideMedia;
+    /**
+     * A model the request is sent to instead of the default when the call names
+     * no model, no model variable is set, and the request carries media or a
+     * question of one of `questionTypes`. Its `decisionLimits` row is the one
+     * checked. For a text default that cannot read those requests, whose server
+     * would otherwise hand them to this model behind its back, with a smaller
+     * window than the one checked. Omitted means the default model is always sent.
+     */
+    capableModel?: DecideCapableModel;
     /**
      * Keeps a key found only in the environment from becoming the default
      * decision provider when it plainly belongs to something else. Omitted means
@@ -368,6 +377,8 @@ export type DecideCatalogJson = {
     };
     timeouts?: {
         decideMs?: number;
+        /** Added to `decideMs` per 1,000 estimated state tokens, for a model whose latency grows with the state. */
+        decideMsPerKStateTokens?: number;
     };
     decisionLimits?: DecisionLimits;
     decide: DecideBlock;

package/dist/types/providers.d.ts

@@ -2459,6 +2459,8 @@ export type ProviderDescriptor = {
         generateMs?: number;
         streamMs?: number;
         decideMs?: number;
+        /** Added to `decideMs` per 1,000 estimated state tokens. */
+        decideMsPerKStateTokens?: number;
     };
     /**
      * What a `decide` provider can read. Absent means the provider leaves size

package/dist/utils/decisionAnswers.d.ts

@@ -7,7 +7,7 @@
  *
  * @module utils/decisionAnswers
  */
-import type { DecisionAnswerMap, DecisionBooleanGate, DecisionChoiceReading, DecisionQuestion, DecisionResult, DecisionScoreReading, ProviderDescriptor } from "../types/index.js";
+import type { DecisionAnswerMap, DecisionBooleanGate, DecisionChoiceReading, DecisionQuestion, DecisionResult, DecisionScoreReading, DecisionValueReading, ProviderDescriptor } from "../types/index.js";
 /**
  * Read a yes/no answer as a probability.
  *
@@ -24,6 +24,12 @@ export declare function readDecisionBoolean(answers: DecisionAnswerMap, id: stri
  */
 export declare function readDecisionChoice(answers: DecisionAnswerMap, id: string): DecisionChoiceReading | undefined;
 export declare function readDecisionScore(answers: DecisionAnswerMap, id: string): DecisionScoreReading | undefined;
+/**
+ * Read an extracted value. `value` is null and `unknown` true when the model
+ * found nothing to extract, which is an answer, not a missing one: undefined
+ * still means the id is absent or the answer was another type.
+ */
+export declare function readDecisionValue(answers: DecisionAnswerMap, id: string): DecisionValueReading | undefined;
 /**
  * A yes/no answer carries no confidence of its own, so certainty has to be
  * inferred from how far the probability sits from a coin flip. 0.5 → 0, and