@juspay/neurolink 12.25.4 → 12.26.0

package/dist/providers/typesafe.js

@@ -1,10 +1,8 @@
 import { TypeSafeModels } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import { isNeuroLink } from "../neurolink.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { ProviderError } from "../types/index.js";
 import { logger } from "../utils/logger.js";
+import { redactUrlForError } from "../utils/logSanitize.js";
 import { getProviderModel } from "../utils/providerConfig.js";
+import { asNumber, DEFAULT_DECISION_TIMEOUT_MS, describeValidationErrors, isRecord, SystemOneDecisionProvider, } from "./systemOneDecision.js";
 const TYPESAFE_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 /**
  * Vercel AI Gateway's evaluation-model endpoint.
@@ -14,7 +12,7 @@ const TYPESAFE_DEFAULT_BASE_URL = "https://api.typesafe.ai";
  * `inferenceKinds`, arrived at independently. The gateway therefore has its
  * own route rather than reusing the chat one.
  */
-const GATEWAY_URL = "https://ai-gateway.vercel.sh/v4/ai/evaluation-model";
+const TYPESAFE_DEFAULT_GATEWAY_URL = "https://ai-gateway.vercel.sh/v4/ai/evaluation-model";
 /** Gateway model id for Jev. The gateway carries it in a header, not the body. */
 const GATEWAY_MODEL_ID = "typesafe-ai/jev";
 /**
@@ -25,13 +23,6 @@ const GATEWAY_MODEL_ID = "typesafe-ai/jev";
 const GATEWAY_PROTOCOL_VERSION = "0.0.1";
 /** Evaluation-model spec version the request body conforms to. */
 const GATEWAY_SPEC_VERSION = "4";
-/**
- * Generous enough for a cold start (measured at 2.0–2.7s after idle) while
- * still bounded. Steady-state p50 is ~400ms, so this only bites on the first
- * call or a genuine stall — and every internal caller is fail-open anyway.
- */
-const DEFAULT_TIMEOUT_MS = 5000;
-const DEFAULT_MAX_RETRIES = 1;
 /**
  * The binding limit in practice: `state` plus the SINGLE LONGEST question.
  * Measured by bisection at single-character resolution — 33,002 reported
@@ -45,112 +36,6 @@ export const TYPESAFE_MAX_STATE_TOKENS = 33_000;
  * 33K budget, only for this one.
  */
 export const TYPESAFE_MAX_REQUEST_TOKENS = 64_000;
-const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-const asNumber = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
-const asNumberMap = (v) => {
-    if (!isRecord(v)) {
-        return undefined;
-    }
-    const out = {};
-    for (const [k, raw] of Object.entries(v)) {
-        const n = asNumber(raw);
-        if (n === undefined) {
-            return undefined;
-        }
-        out[k] = n;
-    }
-    return out;
-};
-const asStringMap = (v) => {
-    if (!isRecord(v)) {
-        return undefined;
-    }
-    const out = {};
-    for (const [k, raw] of Object.entries(v)) {
-        if (typeof raw !== "string") {
-            return undefined;
-        }
-        out[k] = raw;
-    }
-    return out;
-};
-/**
- * Translate the provider-neutral question vocabulary onto TypeSafe's wire.
- *
- * The only difference is the name of the yes/no primitive: TypeSafe calls it
- * `noul`, and everyone exposing it — the Vercel AI SDK, Pydantic AI, and this
- * codebase — calls it `boolean`. Vercel's AI Gateway fronts the same model
- * and uses the neutral name, so the gateway transport needs no translation
- * at all.
- */
-function toWireQuestion(question, transport) {
-    // The gateway already speaks the neutral vocabulary this codebase uses, so
-    // only the direct transport needs the rename.
-    if (question.type === "boolean" && transport === "direct") {
-        return {
-            type: "noul",
-            instructions: question.instructions,
-            ...(question.criteria ? { criteria: question.criteria } : {}),
-        };
-    }
-    return question;
-}
-/**
- * Validate one answer off the wire. Returns null rather than throwing so a
- * single malformed answer degrades to "unanswered" instead of failing the
- * whole batch — the batch may hold hundreds of usable answers.
- */
-function parseAnswer(raw, reportedConfidence) {
-    if (!isRecord(raw)) {
-        return null;
-    }
-    switch (raw.type) {
-        // "noul" is TypeSafe's own spelling; "boolean" is the gateway's, which
-        // renames both the type and the field. Accepting both keeps one parser
-        // for two transports — and keeps the direct path working if TypeSafe
-        // ever adopts the neutral name itself.
-        case "noul":
-        case "boolean": {
-            const probability = asNumber(raw.noul) ?? asNumber(raw.probability);
-            return probability === undefined
-                ? null
-                : { type: "boolean", probability };
-        }
-        case "choice": {
-            const probabilities = asNumberMap(raw.probabilities);
-            if (typeof raw.choice !== "string" || !probabilities) {
-                return null;
-            }
-            return {
-                type: "choice",
-                choice: raw.choice,
-                confidence: asNumber(raw.confidence) ??
-                    reportedConfidence ??
-                    deriveConfidence(probabilities),
-                probabilities,
-            };
-        }
-        case "score": {
-            const score = asNumber(raw.score);
-            const legend = asStringMap(raw.legend);
-            const probabilities = asNumberMap(raw.probabilities);
-            if (score === undefined || !legend || !probabilities) {
-                return null;
-            }
-            return {
-                type: "score",
-                score,
-                confidence: asNumber(raw.confidence) ??
-                    reportedConfidence ??
-                    deriveConfidence(probabilities),
-                legend,
-                probabilities,
-            };
-        }
-        default:
-            return null;
-    }
-}
 /**
  * Per-question confidence the gateway reports out-of-band, keyed by question
  * id, under `providerMetadata.typesafe.confidence`. Absent on the direct
@@ -173,23 +58,6 @@ function readReportedConfidence(payload) {
     }
     return out;
 }
-/**
- * Last-resort confidence, when no transport reported one.
- *
- * The gateway leaves `confidence` off every answer object, so this was once
- * the only value a gateway caller ever saw. It is not: the gateway reports the
- * vendor's calibrated figure under `providerMetadata` (see
- * {@link readReportedConfidence}), which is preferred wherever it is present.
- * This remains the fallback for an answer neither source covers.
- *
- * The peak probability is what a calibrated confidence approximates, but it is
- * NOT the same number, so a threshold tuned against the direct transport does
- * not transfer unexamined; an even distribution lands near 1/N rather than 0.
- */
-function deriveConfidence(probabilities) {
-    const values = Object.values(probabilities);
-    return values.length > 0 ? Math.max(...values) : 0;
-}
 /**
  * Gateway error `type` → our kind. The gateway's own slugs are the only
  * reliable discriminator: it returns 403 for both a credential that cannot
@@ -236,7 +104,7 @@ function parseGatewayError(status, error, requestId, retryable) {
  * breaker under the message "API key rejected", which points the reader at
  * the one thing that is not wrong.
  */
-function parseError(status, body, requestId) {
+function parseTypeSafeError(status, body, requestId) {
     const retryable = status === 429 || status === 529 || status >= 500;
     const gateway = isRecord(body) && isRecord(body.error) ? body.error : undefined;
     if (gateway) {
@@ -244,21 +112,9 @@ function parseError(status, body, requestId) {
     }
     const detail = isRecord(body) ? body.detail : undefined;
     if (Array.isArray(detail)) {
-        const fields = detail
-            .filter(isRecord)
-            .map((d) => {
-            const loc = Array.isArray(d.loc)
-                ? d.loc
-                    .filter((p) => typeof p === "string" || typeof p === "number")
-                    .join(".")
-                : "";
-            const msg = typeof d.msg === "string" ? d.msg : "invalid";
-            return loc ? `${loc}: ${msg}` : msg;
-        })
-            .slice(0, 5);
         return {
             kind: "invalid_request",
-            message: `Request failed validation — ${fields.join("; ") || "unspecified field"}`,
+            message: `Request failed validation — ${describeValidationErrors(detail)}`,
             status,
             requestId,
             retryable: false,
@@ -292,19 +148,17 @@ function parseError(status, body, requestId) {
         : fallback;
     return { kind, message, status, requestId, retryable };
 }
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * TypeSafe Provider — the `decide` inference type only.
  *
  * Jev is a "System One" model: it takes one `state` plus a map of typed
  * questions and returns one typed answer each, evaluated in a single
- * parallel pass. It emits no text, so `generate()` / `stream()` are not
- * available and `getAISDKModel()` throws — the same shape Voyage and Jina
- * already use for embedding-only providers.
+ * parallel pass. The request loop, retries, auth circuit breaker and answer
+ * parsing are shared with every decision provider in
+ * {@link SystemOneDecisionProvider}; this class holds only what is TypeSafe's.
  *
  * Its descriptor declares `inferenceKinds: ["decide"]`, which keeps it out
- * of auto-select and the health sweep, so those throws should be unreachable
- * in practice.
+ * of auto-select and the health sweep.
  *
  * Two measured properties shape the API: latency is flat in question count
  * (1 question 393ms, 400 questions 465ms) while concurrent requests queue.
@@ -314,31 +168,19 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  * billed against a TypeSafe key. The gateway one is Vercel's AI Gateway
  * evaluation-model route, billed against a Vercel account — useful to a host
  * that already has one and does not want a second vendor relationship. They
- * differ on the wire (vocabulary, where the model is named, and whether
- * `confidence` is reported at all) and not at all in `DecisionResult`; the
- * one thing to know is that gateway confidence is DERIVED from the
- * probability distribution rather than being the vendor's calibrated figure,
- * so a threshold tuned on one transport should be re-checked on the other.
+ * differ on the wire (vocabulary, where the model is named, and where
+ * `confidence` is reported) and not at all in `DecisionResult`.
  *
  * @see https://docs.typesafe.ai/api
  */
-export class TypeSafeProvider extends BaseProvider {
+export class TypeSafeProvider extends SystemOneDecisionProvider {
     apiKey;
     baseURL;
-    proxyFetch;
-    maxRetries;
+    gatewayURL;
     /** Which wire this instance speaks. Resolved once, in the constructor. */
     transport;
-    /**
-     * Set once the key has been rejected. A bad key cannot fix itself, and
-     * without this every later request would pay a full round trip (~265ms
-     * measured) to be told so again — a permanent tax on the hot path for a
-     * misconfiguration.
-     */
-    authFailed = false;
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "typesafe", validatedNeurolink);
+        super(modelName, "typesafe", sdk);
         const directKey = credentials?.apiKey?.trim() ||
             (process.env.TYPESAFE_API_KEY?.trim() ?? "");
         const gatewayKey = credentials?.gatewayApiKey?.trim() ||
@@ -359,223 +201,74 @@ export class TypeSafeProvider extends BaseProvider {
         this.baseURL = (credentials?.baseURL ??
             process.env.TYPESAFE_BASE_URL ??
             TYPESAFE_DEFAULT_BASE_URL).replace(/\/+$/, "");
-        this.proxyFetch = createProxyFetch();
-        this.maxRetries = DEFAULT_MAX_RETRIES;
+        this.gatewayURL = (credentials?.gatewayURL?.trim() ||
+            process.env.TYPESAFE_GATEWAY_URL?.trim() ||
+            TYPESAFE_DEFAULT_GATEWAY_URL).replace(/\/+$/, "");
         logger.debug("TypeSafe Provider initialized (decide only)", {
             modelName: this.modelName,
             transport: this.transport,
-            baseURL: this.transport === "gateway" ? GATEWAY_URL : this.baseURL,
+            baseURL: redactUrlForError(this.transport === "gateway" ? this.gatewayURL : this.baseURL),
         });
     }
-    // ===== Required abstract overrides =====
-    getProviderName() {
-        return this.providerName;
-    }
     getDefaultModel() {
         return getProviderModel("TYPESAFE_MODEL", TypeSafeModels.JEV_LATEST);
     }
-    getDefaultDecisionModel() {
-        return this.getDefaultModel();
+    vendorLabel() {
+        return "TypeSafe";
+    }
+    vendorDisplayName() {
+        return "TypeSafe (Jev)";
     }
-    supportsTools() {
-        return false;
+    decisionApiKey() {
+        return this.apiKey;
+    }
+    missingKeyMessage() {
+        return this.transport === "gateway"
+            ? "The TypeSafe gateway transport requires a Vercel AI Gateway key. Set AI_GATEWAY_API_KEY or pass credentials.typesafe.gatewayApiKey."
+            : "TypeSafe requires an API key. Set TYPESAFE_API_KEY or pass credentials.typesafe.apiKey.";
     }
     /**
-     * Jev produces no text, so there is no chat model behind this provider.
-     * Unreachable while the descriptor declares `inferenceKinds: ["decide"]`;
-     * kept actionable for the case where something routes here anyway.
+     * The gateway already speaks the neutral vocabulary this codebase uses, so
+     * only the direct transport needs the `noul` rename.
      */
-    getAISDKModel() {
-        throw new ProviderError("TypeSafe (Jev) is a decision-only provider; it generates no text, so chat completions are not available. Use `decide()` instead, or pick a different provider for `generate()` / `stream()`.", "typesafe");
-    }
-    async executeStream(_options, _analysisSchema) {
-        throw new ProviderError("TypeSafe (Jev) is a decision-only provider; streaming is not available. Use `decide()`, or pick another provider for `stream()`.", "typesafe");
+    encodeQuestion(question) {
+        return this.transport === "gateway"
+            ? question
+            : super.encodeQuestion(question);
     }
     /**
-     * Must RETURN the error, never throw it (CLAUDE.md rule 6).
+     * The gateway names the model in a header and rejects a body that carries
+     * one; the direct API requires it in the body.
      */
-    formatProviderError(error) {
-        if (error instanceof ProviderError) {
-            return error;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        return new ProviderError(`TypeSafe request failed: ${message}`, "typesafe");
+    buildDecisionBody(state, questions, model) {
+        return this.transport === "gateway"
+            ? { state, questions }
+            : { model, state, questions };
+    }
+    parseDecisionError(status, payload, requestId) {
+        return parseTypeSafeError(status, payload, requestId);
     }
-    // ===== The decide inference type =====
     /**
-     * Evaluate a state against a batch of typed questions.
-     *
-     * Throws a {@link ProviderError} carrying a normalised {@link DecisionError}
-     * in `cause`. Internal hot paths should prefer `NeuroLink.tryDecide()`,
-     * which returns null instead.
+     * The gateway does not omit confidence after all — it RELOCATES it, to
+     * `providerMetadata.typesafe.confidence.<questionId>`, and leaves the answer
+     * objects themselves without one. Preferring it over the derived peak
+     * matters because the two disagree on any distribution that is not already
+     * near-certain, and the router's asymmetric bars are tuned against the
+     * vendor's calibrated figure, not against max(probabilities).
      */
-    async decide(request) {
-        if (!this.apiKey) {
-            throw this.decisionError({
-                kind: "authentication",
-                message: this.transport === "gateway"
-                    ? "The TypeSafe gateway transport requires a Vercel AI Gateway key. Set AI_GATEWAY_API_KEY or pass credentials.typesafe.gatewayApiKey."
-                    : "TypeSafe requires an API key. Set TYPESAFE_API_KEY or pass credentials.typesafe.apiKey.",
-                retryable: false,
-            });
-        }
-        if (this.authFailed) {
-            throw this.decisionError({
-                kind: "authentication",
-                message: "TypeSafe rejected this API key earlier; not retrying. Fix the key and construct a new provider.",
-                retryable: false,
-            });
-        }
-        const questionEntries = Object.entries(request.questions);
-        if (questionEntries.length === 0) {
-            throw this.decisionError({
-                kind: "invalid_request",
-                message: "At least one question is required.",
-                retryable: false,
-            });
-        }
-        const wireQuestions = Object.fromEntries(questionEntries.map(([id, question]) => [
-            id,
-            toWireQuestion(question, this.transport),
-        ]));
-        const resolvedModel = request.model ?? this.modelName ?? this.getDefaultModel();
-        // The gateway names the model in a header and rejects a body that carries
-        // one; the direct API requires it in the body.
-        const body = JSON.stringify(this.transport === "gateway"
-            ? { state: request.state, questions: wireQuestions }
-            : {
-                model: resolvedModel,
-                state: request.state,
-                questions: wireQuestions,
-            });
-        const timeoutMs = request.timeoutMs ??
-            this.getDescriptorDecideMs() ??
-            this.defaultTimeout ??
-            DEFAULT_TIMEOUT_MS;
-        let lastError;
-        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-            const startedAt = Date.now();
-            try {
-                const timeout = AbortSignal.timeout(timeoutMs);
-                const signal = request.signal
-                    ? AbortSignal.any([request.signal, timeout])
-                    : timeout;
-                const response = await this.proxyFetch(this.endpoint(), {
-                    method: "POST",
-                    headers: this.headers(),
-                    body,
-                    signal,
-                });
-                const latencyMs = Date.now() - startedAt;
-                const requestId = response.headers.get("x-typesafe-request-id") ?? undefined;
-                const upstreamMs = Number(response.headers.get("x-envoy-upstream-service-time")) ||
-                    undefined;
-                const payload = await response.json().catch(() => null);
-                if (!response.ok) {
-                    lastError = parseError(response.status, payload, requestId);
-                    if (lastError.kind === "authentication") {
-                        this.authFailed = true;
-                        // The breaker is right to trip — none of these clear themselves
-                        // inside one process — but it must not assert WHICH credential
-                        // problem it was. A gateway 403 with a valid key and no card on
-                        // file is not a rejected key, and saying so sends the reader off
-                        // to regenerate the one thing that works.
-                        logger.warn(`TypeSafe: credential not accepted — disabling this provider instance. ${lastError.message}`, {
-                            status: lastError.status,
-                            transport: this.transport,
-                            requestId,
-                        });
-                    }
-                    if (!lastError.retryable || attempt === this.maxRetries) {
-                        throw this.decisionError(lastError);
-                    }
-                    await sleep(2 ** attempt * 250 + Math.random() * 250);
-                    continue;
-                }
-                if (!isRecord(payload) || !isRecord(payload.answers)) {
-                    throw this.decisionError({
-                        kind: "server",
-                        message: "TypeSafe returned a response without an answers map.",
-                        status: response.status,
-                        requestId,
-                        retryable: false,
-                    });
-                }
-                // The gateway does not omit confidence after all — it RELOCATES it,
-                // to `providerMetadata.typesafe.confidence.<questionId>`, and leaves
-                // the answer objects themselves without one. Preferring it over the
-                // derived peak matters because the two disagree on any distribution
-                // that is not already near-certain, and the router's asymmetric bars
-                // are tuned against the vendor's calibrated figure, not against
-                // max(probabilities).
-                const reported = readReportedConfidence(payload);
-                const answers = {};
-                for (const [id, raw] of Object.entries(payload.answers)) {
-                    const parsed = parseAnswer(raw, reported[id]);
-                    if (parsed) {
-                        answers[id] = parsed;
-                    }
-                    else {
-                        logger.warn(`TypeSafe: dropped unparseable answer "${id}"`, {
-                            requestId,
-                        });
-                    }
-                }
-                const usage = isRecord(payload.usage) ? payload.usage : {};
-                return {
-                    // `resolvedModel`, not `this.modelName`: when the caller pinned a
-                    // model for this one request and the response omits its own, the
-                    // instance default would be reported instead of the model actually
-                    // asked for.
-                    model: typeof payload.model === "string" ? payload.model : resolvedModel,
-                    provider: this.providerName,
-                    answers,
-                    // Two spellings for one field. The direct API sends `input_tokens`;
-                    // the gateway sends `inputTokens`. Reading only the first meant every
-                    // gateway decision reported zero tokens — and since decisions are
-                    // priced on input alone, every gateway decision was also costed at
-                    // exactly $0, silently, in both the span attributes and the cost
-                    // aggregate. Nothing failed; the number was simply always zero.
-                    usage: {
-                        inputTokens: asNumber(usage.input_tokens) ?? asNumber(usage.inputTokens) ?? 0,
-                        outputTokens: asNumber(usage.output_tokens) ??
-                            asNumber(usage.outputTokens) ??
-                            0,
-                    },
-                    requestId,
-                    latencyMs,
-                    upstreamMs,
-                };
-            }
-            catch (error) {
-                if (error instanceof ProviderError) {
-                    throw error;
-                }
-                // An abort from the caller's own signal must not be retried — the
-                // turn is already being torn down.
-                const aborted = request.signal?.aborted === true;
-                const isTimeout = error instanceof Error && error.name === "TimeoutError";
-                lastError = {
-                    kind: aborted ? "network" : isTimeout ? "timeout" : "network",
-                    message: error instanceof Error ? error.message : String(error),
-                    retryable: !aborted,
-                };
-                if (aborted || attempt === this.maxRetries) {
-                    throw this.decisionError(lastError);
-                }
-                await sleep(2 ** attempt * 250 + Math.random() * 250);
-            }
-        }
-        throw this.decisionError(lastError ?? {
-            kind: "network",
-            message: "TypeSafe request failed.",
-            retryable: false,
-        });
+    reportedConfidence(payload) {
+        return readReportedConfidence(payload);
+    }
+    readRequestId(headers) {
+        return headers.get("x-typesafe-request-id") ?? undefined;
+    }
+    diagnosticContext() {
+        return { transport: this.transport };
     }
     /** Where a decision request goes for this instance's transport. */
-    endpoint() {
+    decisionEndpoint() {
         return this.transport === "gateway"
-            ? GATEWAY_URL
+            ? this.gatewayURL
             : `${this.baseURL}/v1/systemone`;
     }
     /**
@@ -587,7 +280,7 @@ export class TypeSafeProvider extends BaseProvider {
      * carries no `model`), and `ai-evaluation-model-specification-version`
      * selects the request/response shape this provider parses.
      */
-    headers() {
+    decisionHeaders() {
         const base = {
             Authorization: `Bearer ${this.apiKey}`,
             "Content-Type": "application/json",
@@ -623,11 +316,11 @@ export class TypeSafeProvider extends BaseProvider {
         }
         const response = await this.proxyFetch(`${this.baseURL}/v1/models`, {
             headers: { Authorization: `Bearer ${this.apiKey}` },
-            signal: AbortSignal.timeout(this.defaultTimeout ?? DEFAULT_TIMEOUT_MS),
+            signal: AbortSignal.timeout(this.defaultTimeout ?? DEFAULT_DECISION_TIMEOUT_MS),
         });
         const payload = await response.json().catch(() => null);
         if (!response.ok) {
-            throw this.decisionError(parseError(response.status, payload, response.headers.get("x-typesafe-request-id") ?? undefined));
+            throw this.decisionError(parseTypeSafeError(response.status, payload, response.headers.get("x-typesafe-request-id") ?? undefined));
         }
         const models = isRecord(payload) && Array.isArray(payload.models) ? payload.models : [];
         return models.filter(isRecord).map((m) => ({
@@ -636,19 +329,4 @@ export class TypeSafeProvider extends BaseProvider {
             releaseDate: typeof m.release_date === "string" ? m.release_date : "",
         }));
     }
-    /**
-     * Wrap a normalised decision failure in the provider error type, keeping
-     * the structured detail reachable via `cause` for callers that branch on
-     * `kind` (authentication vs rate_limit vs max_tokens_exceeded).
-     */
-    decisionError(detail) {
-        const error = new ProviderError(detail.message, "typesafe");
-        Object.defineProperty(error, "cause", {
-            value: detail,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-        });
-        return error;
-    }
 }

package/dist/routing/classifierRouter.d.ts

@@ -52,8 +52,8 @@ export declare class ClassifierRouter {
     route(input: ClassifierRouterInput): Promise<ClassifierRouterDecision | null>;
     /**
      * Resolve "auto" (the default) to a concrete strategy. Jev is preferred the
-     * moment a TypeSafe key is present; without one the behaviour is exactly
-     * what it was before Jev existed.
+     * moment a decision provider is configured; without one the behaviour is
+     * exactly what it was before Jev existed.
      */
     private resolveStrategy;
     /** Run the chosen strategy; every one falls back to heuristic on failure. */

package/dist/routing/classifierRouter.js

@@ -135,20 +135,22 @@ export class ClassifierRouter {
     }
     /**
      * Resolve "auto" (the default) to a concrete strategy. Jev is preferred the
-     * moment a TypeSafe key is present; without one the behaviour is exactly
-     * what it was before Jev existed.
+     * moment a decision provider is configured; without one the behaviour is
+     * exactly what it was before Jev existed.
      */
     resolveStrategy() {
         const configured = this.config.classifier ?? "auto";
         if (configured !== "auto") {
             return configured;
         }
-        // A decision provider that is both registered AND has its key set is the
-        // whole activation condition — this is where "if somebody sets it we
-        // start using it" lives for routing.
-        return this.deps.decide && resolveDefaultDecisionProvider()
-            ? "jev"
-            : "heuristic";
+        // A decision provider that is both registered AND configured is the whole
+        // activation condition — this is where "if somebody sets it we start
+        // using it" lives for routing. The caller's check also counts the
+        // credentials it was constructed with.
+        const hasProvider = this.deps.hasDecisionProvider
+            ? this.deps.hasDecisionProvider()
+            : resolveDefaultDecisionProvider() !== undefined;
+        return this.deps.decide && hasProvider ? "jev" : "heuristic";
     }
     /** Run the chosen strategy; every one falls back to heuristic on failure. */
     async classify(strategy, input, candidates) {

package/dist/types/classifierRouter.d.ts

@@ -24,7 +24,9 @@ export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" |
  * - `llm` — a cheap classifier model via the injected `generate`.
  * - `jev` — TypeSafe's System One model; one ~400ms round trip that returns a
  *   *calibrated* confidence rather than a self-reported one.
- * - `auto` — `jev` when `TYPESAFE_API_KEY` is set, otherwise `heuristic`.
+ * - `auto` — `jev` when a decision provider is configured, in the environment
+ *   or in SDK credentials (`TYPESAFE_API_KEY`, or `LAYA_API_KEY` with
+ *   `LAYA_BASE_URL`), otherwise `heuristic`.
  */
 export type ClassifierStrategyKind = "heuristic" | "llm" | "jev" | "auto";
 /**
@@ -182,8 +184,10 @@ export type ClassifierRouterConfig = {
     /** Master switch. When false/absent, the router is never built. */
     enabled: boolean;
     /**
-     * Classification strategy. Default: "auto" — which resolves to "jev" when
-     * `TYPESAFE_API_KEY` is set and "heuristic" otherwise, so configuring a key
+     * Classification strategy. Default: "auto" — which resolves to "jev" when a
+     * decision provider is configured, in the environment or in SDK credentials
+     * (`TYPESAFE_API_KEY`, or `LAYA_API_KEY` with `LAYA_BASE_URL`) and
+     * "heuristic" otherwise, so configuring one
      * upgrades routing without any code change. Behaviour for callers with no
      * key is unchanged.
      */
@@ -350,5 +354,11 @@ export type ClassifierRouterDeps = {
     generate?: ClassifierGenerateFn;
     /** Decision caller for the "jev" strategy. Omit to disable it. */
     decide?: ClassifierDecideFn;
+    /**
+     * Whether a decision provider is configured for this caller, counting the
+     * credentials it was given as well as the environment. Omit to check the
+     * environment alone.
+     */
+    hasDecisionProvider?: () => boolean;
     logger?: ClassifierLogger;
 };