@juspay/neurolink 13.4.10 → 13.5.1

package/dist/processors/index.js

@@ -64,6 +64,10 @@
  * });
  * ```
  */
+// Imported on its own, this entry starts tracing at its first span, as the
+// main entry does. The import sits here rather than in the shared tracers so
+// that the client entry stays free of the OpenTelemetry Node SDK.
+import "../services/server/ai/observability/instrumentation.js";
 // =============================================================================
 // BASE PROCESSOR INFRASTRUCTURE (single source of truth for ALL types)
 // =============================================================================

package/dist/processors/registry/ProcessorRegistry.d.ts

@@ -44,6 +44,7 @@
  * ```
  */
 import type { FileInfo, ProcessorFileProcessingResult, ProcessedFileBase, ProcessOptions, ProcessorMatch, RegistryOptions, RegistryProcessResult, ProcessorRegistration } from "../../types/index.js";
+import "../../services/server/ai/observability/instrumentation.js";
 /**
  * Central registry for file processors.
  * Uses singleton pattern and priority-based selection.

package/dist/processors/registry/ProcessorRegistry.js

@@ -45,6 +45,10 @@
  */
 import { withSpan } from "../../telemetry/withSpan.js";
 import { tracers } from "../../telemetry/tracers.js";
+// Starts tracing at the first span, as this module always did: the shared
+// tracers only start what a loaded entry registered, and this path can be
+// imported without the package entry. The client entry stays free of it.
+import "../../services/server/ai/observability/instrumentation.js";
 // =============================================================================
 // UTILITY FUNCTIONS
 // =============================================================================
@@ -404,6 +408,7 @@ export class ProcessorRegistry {
         return withSpan({
             name: "neurolink.processor.processFile",
             tracer: tracers.processor,
+            observationType: "span",
             attributes: {
                 "processor.filename": fileInfo.name ?? "unknown",
                 "processor.mimetype": fileInfo.mimetype ?? "unknown",

package/dist/providers/amazonBedrock/client.js

@@ -279,9 +279,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             }
             throw error;
         }
-        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION observation.
-        // Bedrock bypasses the Vercel AI SDK so experimental_telemetry is never injected;
-        // we emit the event manually to fill that gap.
+        // Emit generation:end for the event listeners and the in-process metrics
+        // aggregator. Bedrock bypasses the Vercel AI SDK so nothing else emits it;
+        // its Langfuse GENERATION observations are the loop's own per-step spans.
         const generateEmitter = this.neurolink?.getEventEmitter();
         if (generateEmitter) {
             generateEmitter.emit("generation:end", {
@@ -383,6 +383,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 }),
             });
             const { resultPromise } = runAgenticLoop(adapter, conversation, {
+                operation: "generate",
                 tools: this.toEngineTools(tools),
                 abortSignal: signal,
                 // `toEngineTools` adds no deadline of its own, so this is the only
@@ -1261,6 +1262,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 },
             };
             return runAgenticLoop(adapter, conversation, {
+                operation: "stream",
                 tools: this.toEngineTools(tools),
                 abortSignal: signal,
                 // `toEngineTools` adds no deadline of its own, so this is the only
@@ -1368,8 +1370,8 @@ export class AmazonBedrockProvider extends BaseProvider {
                     // Analytics is resolved off `settled` above, so it lands whether or
                     // not anyone drains the stream.
                     // Bedrock bypasses the Vercel AI SDK, so experimental_telemetry is
-                    // never injected and generation:end is emitted by hand for
-                    // Pipeline B (Langfuse).
+                    // never injected and generation:end is emitted by hand for the
+                    // event listeners and the in-process metrics aggregator.
                     if (streamEmitter) {
                         // #1741: tell the orchestration's finally block this stream's
                         // `generation:end` has already been emitted here, exactly as the

package/dist/providers/amazonSagemaker.js

@@ -13,6 +13,7 @@ import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGener
 import { generationName } from "../telemetry/observationNames.js";
 import { observeGeneration } from "../telemetry/observation.js";
 import { tracers } from "../telemetry/tracers.js";
+import { markFailure } from "../telemetry/withSpan.js";
 // SageMaker-specific imports
 import { getDefaultSageMakerEndpoint, getSageMakerConfig, getSageMakerModel, getSageMakerModelConfig, } from "./sagemaker/config.js";
 import { handleSageMakerError, SageMakerError } from "./sagemaker/errors.js";
@@ -375,10 +376,18 @@ export class AmazonSageMakerProvider extends BaseProvider {
                     span.setStatus({ code: SpanStatusCode.OK });
                 }
                 catch (error) {
-                    span.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: error instanceof Error ? error.message : String(error),
-                    });
+                    markFailure(span, error);
+                    // markFailure leaves an abort at WARNING; the released pump ended
+                    // every failure at ERROR, an abort included.
+                    try {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    catch {
+                        // An error whose text cannot be read is already recorded above.
+                    }
                     channel.error(error);
                 }
                 finally {
@@ -390,14 +399,25 @@ export class AmazonSageMakerProvider extends BaseProvider {
                         settleFinishReason("unknown");
                         settleUsage({ inputTokens: 0, outputTokens: 0 });
                     }
-                    observeGeneration(span, {
-                        ...call,
-                        output: text,
-                        usage: tokens,
-                        finishReason: finish,
-                        completionStartTime: firstChunkAt,
-                    });
-                    span.end();
+                    // Recording is best effort and span.end() must follow it either
+                    // way: this pump is detached, so nothing else would catch a throw.
+                    try {
+                        observeGeneration(span, {
+                            ...call,
+                            output: text,
+                            usage: tokens,
+                            finishReason: finish,
+                            completionStartTime: firstChunkAt,
+                        });
+                    }
+                    catch (error) {
+                        logger.debug("[SageMaker] Failed to record the stream generation", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    finally {
+                        span.end();
+                    }
                 }
             })();
             return {

package/dist/providers/anthropic/client.js

@@ -2208,6 +2208,7 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 : undefined;
             const { stream, resultPromise } = runAgenticLoop(adapter, payload.messages.slice(), {
+                operation: "stream",
                 tools: engineTools,
                 ...(abortSignal ? { abortSignal } : {}),
                 ...(activeSpan ? { span: activeSpan } : {}),

package/dist/providers/anthropic/loopAdapter.js

@@ -401,9 +401,13 @@ export function createAnthropicLoopAdapter(config) {
                             ? params.thinking.budget_tokens
                             : undefined,
                     },
-                    input: {
-                        system: params.system,
-                        messages: sanitizeAnthropicMessagesForTrace(params.messages),
+                    // Read only by a recording span, so a request nobody traces is not
+                    // copied and sanitized on every step.
+                    get input() {
+                        return {
+                            system: params.system,
+                            messages: sanitizeAnthropicMessagesForTrace(params.messages),
+                        };
                     },
                 },
             };

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

@@ -55,6 +55,25 @@
       "properties": {
         "maxStateTokens": { "type": "integer", "minimum": 1 },
         "maxQuestions": { "type": "integer", "minimum": 1 },
+        "questionTypes": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "enum": ["boolean", "choice", "score", "value", "choice-unknown"]
+          },
+          "description": "The question types the provider reads; choice-unknown is a choice that sets unknown: true. Absent means boolean, choice and score. openai-decisions may list only boolean, choice and score."
+        },
+        "maxScoreLevels": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Most levels one score question may have."
+        },
+        "maxChoiceOptions": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Most options one choice question may have."
+        },
         "nonAsciiTokensPerChar": { "type": "number", "exclusiveMinimum": 0 },
         "digitTokensPerChar": { "type": "number", "exclusiveMinimum": 0 },
         "symbolTokensPerChar": { "type": "number", "exclusiveMinimum": 0 },
@@ -75,6 +94,19 @@
               "type": "integer",
               "minimum": 1,
               "description": "Ceiling on the encoded request body, in bytes."
+            },
+            "audio": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["maxSeconds"],
+              "description": "One audio clip is accepted. Requires decide.media.audioKey; not valid with openai-decisions.",
+              "properties": {
+                "maxSeconds": {
+                  "type": "integer",
+                  "minimum": 1,
+                  "description": "Seconds of audio the model reads; a WAV, FLAC or Ogg clip that runs longer is refused."
+                }
+              }
             }
           }
         },
@@ -154,10 +186,32 @@
           "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. With dialect system-one it requires decisionLimits.media, and videoKey is required exactly when that allowance's video is true. Not valid with openai-decisions.",
+          "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, audioKey only when it carries audio, and all differ. With dialect system-one it requires decisionLimits.media; videoKey is required exactly when that allowance's video is true, and audioKey exactly when it sets audio. Not valid with openai-decisions.",
           "properties": {
             "imagesKey": { "$ref": "#/definitions/decideMediaKey" },
-            "videoKey": { "$ref": "#/definitions/decideMediaKey" }
+            "videoKey": { "$ref": "#/definitions/decideMediaKey" },
+            "audioKey": { "$ref": "#/definitions/decideMediaKey" }
+          }
+        },
+        "capableModel": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["model", "questionTypes"],
+          "description": "A models.catalog key (not the default) 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; that model's decisionLimits row is the one checked. questionTypes must be listed in decisionLimits.questionTypes.",
+          "properties": {
+            "model": { "type": "string", "minLength": 1 },
+            "questionTypes": {
+              "type": "array",
+              "items": {
+                "enum": [
+                  "boolean",
+                  "choice",
+                  "score",
+                  "value",
+                  "choice-unknown"
+                ]
+              }
+            }
           }
         },
         "ambientKeyGuard": {
@@ -570,6 +624,11 @@
           "type": "integer",
           "minimum": 1,
           "description": "Decide entries only: the per-call budget for decide(), in milliseconds. When omitted, the base provider's default timeout applies."
+        },
+        "decideMsPerKStateTokens": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Decide entries only: added to decideMs for every 1,000 estimated state tokens, for a model whose latency grows with the state."
         }
       }
     },
@@ -690,7 +749,9 @@
           "defaultMaxOutputTokens"
         ]
       },
-      "timeouts": { "properties": { "decideMs": false } }
+      "timeouts": {
+        "properties": { "decideMs": false, "decideMsPerKStateTokens": false }
+      }
     }
   },
   "definitions": {

package/dist/providers/catalog/schema.js

@@ -540,11 +540,30 @@ const decideMediaSchema = z
     .strictObject({
     imagesKey: decideMediaKeySchema,
     videoKey: decideMediaKeySchema.optional(),
+    audioKey: decideMediaKeySchema.optional(),
 })
     .refine((media) => media.imagesKey !== media.videoKey, {
     path: ["videoKey"],
     message: "decide.media.videoKey must differ from imagesKey: one body key cannot carry both",
+})
+    .refine((media) => media.audioKey === undefined ||
+    (media.audioKey !== media.imagesKey && media.audioKey !== media.videoKey), {
+    path: ["audioKey"],
+    message: "decide.media.audioKey must differ from imagesKey and videoKey: one body key cannot carry two kinds of media",
 });
+const DECIDE_QUESTION_TYPES = [
+    "boolean",
+    "choice",
+    "score",
+    "value",
+    "choice-unknown",
+];
+// The openai-decisions dialect writes predicates, choices and levels only.
+const OPENAI_DECISIONS_QUESTION_TYPES = new Set([
+    "boolean",
+    "choice",
+    "score",
+]);
 const GUARD_LIST_MAX = 8;
 const ambientGuardEnvNameSchema = z
     .string()
@@ -603,6 +622,12 @@ const decideBlockSchema = z.strictObject({
     authHeader: z.enum(["bearer", "x-api-key"]).optional(),
     stateEncoding: z.enum(["text"]).optional(),
     media: decideMediaSchema.optional(),
+    capableModel: z
+        .strictObject({
+        model: z.string().min(1),
+        questionTypes: z.array(z.enum(DECIDE_QUESTION_TYPES)),
+    })
+        .optional(),
     ambientKeyGuard: ambientKeyGuardSchema.optional(),
     requestIdHeaders: z.array(decideHeaderNameSchema).optional(),
     response: z
@@ -653,6 +678,15 @@ const decideModelsSchema = z
 const decideLimitsSchema = z.strictObject({
     maxStateTokens: decidePositiveInt,
     maxQuestions: decidePositiveInt.optional(),
+    questionTypes: z
+        .array(z.enum(DECIDE_QUESTION_TYPES))
+        .min(1)
+        .refine((types) => new Set(types).size === types.length, {
+        message: "decisionLimits.questionTypes lists the same type twice",
+    })
+        .optional(),
+    maxScoreLevels: decidePositiveInt.optional(),
+    maxChoiceOptions: decidePositiveInt.optional(),
     nonAsciiTokensPerChar: decidePositiveNumber.optional(),
     digitTokensPerChar: decidePositiveNumber.optional(),
     symbolTokensPerChar: decidePositiveNumber.optional(),
@@ -668,10 +702,36 @@ const decideLimitsSchema = z.strictObject({
         maxImages: decidePositiveInt,
         video: z.boolean(),
         maxRequestBytes: decidePositiveInt,
+        audio: z.strictObject({ maxSeconds: decidePositiveInt }).optional(),
     })
         .optional(),
     advisory: z.boolean().optional(),
 });
+// decide.capableModel names another key of the catalog, never the default, and
+// only question types the entry reads: anything else is refused before a model
+// is chosen.
+function checkCapableModel(entry, modelKeys, issue) {
+    const capable = entry.decide.capableModel;
+    if (capable === undefined) {
+        return;
+    }
+    if (!modelKeys.has(capable.model)) {
+        issue(["decide", "capableModel", "model"], "decide.capableModel.model must be a key of models.catalog");
+    }
+    if (capable.model === entry.models.default) {
+        issue(["decide", "capableModel", "model"], "decide.capableModel.model must differ from models.default: a request is sent to it instead of the default");
+    }
+    const declared = entry.decisionLimits?.questionTypes ?? [
+        "boolean",
+        "choice",
+        "score",
+    ];
+    capable.questionTypes.forEach((type, index) => {
+        if (!declared.includes(type)) {
+            issue(["decide", "capableModel", "questionTypes", index], `decide.capableModel.questionTypes lists ${type}, which decisionLimits.questionTypes does not: such a question is refused before any model is chosen`);
+        }
+    });
+}
 const decideCatalogJsonSchema = z
     .strictObject({
     ...catalogIdentityShape,
@@ -680,7 +740,10 @@ const decideCatalogJsonSchema = z
     wire: decideWireSchema,
     models: decideModelsSchema,
     timeouts: z
-        .strictObject({ decideMs: decidePositiveInt.optional() })
+        .strictObject({
+        decideMs: decidePositiveInt.optional(),
+        decideMsPerKStateTokens: decidePositiveInt.optional(),
+    })
         .optional(),
     decisionLimits: decideLimitsSchema.optional(),
     decide: decideBlockSchema,
@@ -743,6 +806,7 @@ const decideCatalogJsonSchema = z
     if (alias !== undefined && !modelKeys.has(alias)) {
         issue(["decide", "model", "alias"], "decide.model.alias must be a key of models.catalog");
     }
+    checkCapableModel(entry, modelKeys, issue);
     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");
@@ -763,6 +827,14 @@ const decideCatalogJsonSchema = z
         if (placement !== "body") {
             issue(["decide", "model", "placement"], "decide.model.placement must be body with dialect openai-decisions: the model is always a field of the request");
         }
+        if (mediaAllowance?.audio !== undefined) {
+            issue(["decisionLimits", "media", "audio"], "decisionLimits.media.audio is not valid with dialect openai-decisions: its request input has no audio part");
+        }
+        (entry.decisionLimits?.questionTypes ?? []).forEach((type, index) => {
+            if (!OPENAI_DECISIONS_QUESTION_TYPES.has(type)) {
+                issue(["decisionLimits", "questionTypes", index], `decisionLimits.questionTypes cannot list ${type} with dialect openai-decisions: that dialect writes boolean, choice and score questions only`);
+            }
+        });
     }
     else {
         if (mediaKeys !== undefined && mediaAllowance === undefined) {
@@ -778,6 +850,14 @@ const decideCatalogJsonSchema = z
             if (!mediaAllowance.video && mediaKeys.videoKey !== undefined) {
                 issue(["decide", "media", "videoKey"], "decide.media.videoKey must be omitted when decisionLimits.media.video is false");
             }
+            if (mediaAllowance.audio !== undefined &&
+                mediaKeys.audioKey === undefined) {
+                issue(["decide", "media", "audioKey"], "decide.media.audioKey is required when decisionLimits.media.audio is set");
+            }
+            if (mediaAllowance.audio === undefined &&
+                mediaKeys.audioKey !== undefined) {
+                issue(["decide", "media", "audioKey"], "decide.media.audioKey must be omitted when decisionLimits.media.audio is not set");
+            }
         }
     }
     if (decide.baseURLRequired === true &&

package/dist/providers/catalog/xor.json

@@ -10,18 +10,18 @@
         "topModels": ["xor-latest", "xor-omni"],
         "catalog": {
             "xor-latest": {
-                "contextWindow": 250000,
+                "contextWindow": 131072,
                 "maxOutputTokens": 256,
                 "vision": false,
                 "status": "production",
-                "description": "Recommended - XOR text alias; boolean, choice and score questions, 2 to 64 options each"
+                "description": "Recommended - XOR text alias; boolean, choice and score questions over a 131,072-token window. A request with a value question, an image or audio goes to xor-omni when no model was chosen (decide.capableModel)"
             },
             "xor-omni": {
-                "contextWindow": 250000,
+                "contextWindow": 32768,
                 "maxOutputTokens": 256,
                 "vision": true,
                 "status": "production",
-                "description": "XOR multimodal alias; reads images and video alongside the state, for boolean, choice and score questions"
+                "description": "XOR multimodal alias; boolean, choice, score and value questions over a 32,768-token window, plus one image and up to 30 seconds of audio"
             },
             "xor-1.1": {
                 "contextWindow": 250000,
@@ -32,11 +32,24 @@
             }
         }
     },
-    "timeouts": { "decideMs": 5000 },
+    "timeouts": { "decideMs": 5000, "decideMsPerKStateTokens": 150 },
     "decisionLimits": {
-        "maxStateTokens": 200000,
+        "maxStateTokens": 28000,
+        "maxQuestions": 128,
+        "questionTypes": ["boolean", "choice", "score", "value", "choice-unknown"],
+        "maxScoreLevels": 10,
+        "maxChoiceOptions": 64,
         "nonAsciiTokensPerChar": 1,
-        "media": { "maxImages": 8, "video": true, "maxRequestBytes": 8388608 }
+        "models": {
+            "xor-latest": { "maxStateTokens": 120000 },
+            "xor-omni": { "maxStateTokens": 28000 }
+        },
+        "media": {
+            "maxImages": 1,
+            "video": false,
+            "maxRequestBytes": 25000000,
+            "audio": { "maxSeconds": 30 }
+        }
     },
     "decide": {
         "dialect": "system-one",
@@ -46,7 +59,8 @@
         "baseURLShape": "origin",
         "endpoint": "{baseURL}/v1/decisions",
         "model": { "placement": "body" },
-        "media": { "imagesKey": "images", "videoKey": "video" },
+        "media": { "imagesKey": "images", "audioKey": "audio" },
+        "capableModel": { "model": "xor-omni", "questionTypes": ["value"] },
         "requestIdHeaders": [
             "x-request-id",
             "x-typesafe-request-id",
@@ -63,6 +77,12 @@
                     "messagePattern": "(context|prefill|prompt).{0,40}(length|limit|too long|exceed)|(too long|exceeds?).{0,40}(context|tokens)",
                     "kind": "max_tokens_exceeded"
                 },
+                {
+                    "statusMin": 500,
+                    "messagePattern": "backend 4[0-9]{2}",
+                    "kind": "invalid_request",
+                    "retryable": false
+                },
                 { "statusMin": 500, "kind": "server" }
             ],
             "default": "invalid_request",
@@ -91,8 +111,8 @@
     },
     "evidence": {
         "rosterVerified": {
-            "date": "2026-10-18",
-            "method": "POST <origin>/v1/decisions with model xor-latest and a 3-option choice question returned HTTP 200 with served model xor-text-2, through NeuroLink's decide(); a 65-option choice question returned HTTP 422 reading 2..64 options, got 65. A 64-option question returned 200 and 77 options returned 422 on both aliases when probed by hand the same day. A successful xor-omni answer, and any image, audio or video request, were not exercised. The figures contextWindow 250000, maxOutputTokens 256, the 200000-token state window and the media limits are carried over from xor-1.1, not re-measured for the aliases; xor-1.1 is kept only as a retired name"
+            "date": "2026-10-19",
+            "method": "Probed POST <origin>/v1/decisions through a LiteLLM gateway with both aliases. xor-latest read a needle at 120,076 input tokens and refused 200,076 as longer than its 131,072-token context; xor-omni refused past 32,768. 128 questions were answered and 256 refused; a choice took 64 options (63 plus unknown; 64 plus unknown crashed with a 500); a score took 10 levels and 11 were refused by the gateway. value answered int, float and pattern-bound strings on xor-omni, and on xor-latest through the gateway's fallback to xor-omni. One image was read (a second was refused with 422) at a fixed ~600 tokens whatever its resolution. Audio as {data, format} was heard in WAV, FLAC, Ogg, Opus and MP3 (an English speech clip identified at 0.9999 in each) at ~25 tokens a second and cut at 30 seconds, keeping the start; M4A/AAC decoded to nothing. A video, sent as a data URL or as {data, format}, returned the same answer as garbage bytes, so the gateway drops it. The body cap was 24 MiB. A malformed image or audio clip and an over-long state returned 502 wrapping the backend's 400"
         },
         "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, DecisionPreparedMedia, DecisionState, UnknownRecord } from "../types/index.js";
+import type { DecideCatalogJson, DecisionDialect, DecisionError, DecisionPreparedMedia, DecisionRequest, 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 {
@@ -14,6 +14,13 @@ export declare class ConfiguredDecisionProvider extends SystemOneDecisionProvide
     protected missingKeyMessage(): string;
     protected missingConfigMessage(): string | undefined;
     protected decisionEndpoint(): string;
+    /**
+     * `decide.capableModel` in place of the default, for a request that carries
+     * media or one of its question types, when nobody chose a model: the call
+     * names none, the model variable is unset, and the instance is on the
+     * default. A model somebody chose is always the one sent.
+     */
+    protected resolveRequestModel(request: DecisionRequest): string;
     protected decisionHeaders(): Record<string, string>;
     /**
      * The state the dialect is given. Only an entry that sets `stateEncoding`

package/dist/providers/configuredDecision.js

@@ -1,3 +1,4 @@
+import { decisionQuestionTypeOf } from "../utils/decisionLimits.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlForError } from "../utils/logSanitize.js";
 import { getProviderModel } from "../utils/providerConfig.js";
@@ -70,6 +71,27 @@ export class ConfiguredDecisionProvider extends SystemOneDecisionProvider {
     decisionEndpoint() {
         return this.endpoint;
     }
+    /**
+     * `decide.capableModel` in place of the default, for a request that carries
+     * media or one of its question types, when nobody chose a model: the call
+     * names none, the model variable is unset, and the instance is on the
+     * default. A model somebody chose is always the one sent.
+     */
+    resolveRequestModel(request) {
+        const chosen = super.resolveRequestModel(request);
+        const capable = this.entry.decide.capableModel;
+        if (capable === undefined ||
+            request.model !== undefined ||
+            chosen !== this.entry.models.default ||
+            readText(process.env[catalogEnvVar(this.entry, "model")]) !== "") {
+            return chosen;
+        }
+        const carriesMedia = (request.images?.length ?? 0) > 0 ||
+            request.video !== undefined ||
+            request.audio !== undefined;
+        const asksFor = Object.values(request.questions).some((question) => capable.questionTypes.includes(decisionQuestionTypeOf(question)));
+        return carriesMedia || asksFor ? capable.model : chosen;
+    }
     decisionHeaders() {
         const credential = this.entry.decide.authHeader === "x-api-key"
             ? { "x-api-key": this.apiKey }

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) => {