@juspay/neurolink 12.18.0 → 12.19.0

package/dist/types/providers.d.ts

@@ -5,6 +5,7 @@ import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js"
 import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
+import type { DecisionRequest, DecisionResult } from "./decision.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "./generate.js";
 import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
@@ -273,6 +274,27 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    /** TypeSafe (Jev) — the `decide` inference type, not text generation. */
+    typesafe?: {
+        apiKey?: string;
+        baseURL?: string;
+        /**
+         * Which transport carries the decision request.
+         *
+         * - `"direct"` — TypeSafe's own API, `POST /v1/systemone`.
+         * - `"gateway"` — Vercel's AI Gateway evaluation-model endpoint, which
+         *   bills through an existing Vercel account instead of a TypeSafe one.
+         *
+         * Omitted resolves automatically: `gateway` when only a gateway key is
+         * present, `direct` otherwise. The two differ on the wire — the gateway
+         * already uses the neutral `boolean`/`probability` vocabulary, carries
+         * the model in a header rather than the body, and omits `confidence`
+         * entirely — but a caller sees the identical `DecisionResult` either way.
+         */
+        transport?: "direct" | "gateway";
+        /** Vercel AI Gateway key. Defaults to `AI_GATEWAY_API_KEY`. */
+        gatewayApiKey?: string;
+    };
 };
 /**
  * Voyage AI /embeddings response shape.
@@ -767,6 +789,16 @@ export type AIProvider = {
      * Generate embedding vectors for multiple text inputs in batch.
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * Evaluate a state against a batch of typed questions — the `decide`
+     * inference type. Implemented by BaseProvider (throws by default, as
+     * `embed` does); only providers whose descriptor declares `"decide"` in
+     * `inferenceKinds` override it.
+     *
+     * Optional so external AIProvider implementations still compile; callers
+     * must treat absence as "this provider cannot decide".
+     */
+    decide?(request: DecisionRequest): Promise<DecisionResult>;
     setupToolExecutor(sdk: {
         customTools: Map<string, unknown>;
         executeTool: (toolName: string, params: unknown) => Promise<unknown>;
@@ -1887,11 +1919,22 @@ export type ProviderRegistration = {
     aliases?: string[];
     descriptor?: ProviderDescriptor;
 };
+/**
+ * The kinds of inference a provider can serve.
+ *
+ * `generate` and `stream` both produce text. `decide` produces typed,
+ * calibrated judgements and no text at all — see src/lib/types/decision.ts.
+ * They are peers: a provider may serve any subset.
+ */
+export type InferenceKind = "generate" | "stream" | "decide";
+/** What a descriptor means when it declares no `inferenceKinds`. */
+export declare const DEFAULT_INFERENCE_KINDS: readonly InferenceKind[];
 /**
  * Single source of truth for one AI provider's static identity: how it's
  * addressed (name/aliases), how it's authenticated (credentialsKey/envVars),
  * what it defaults to (defaultModel), and how the rest of the codebase
- * should treat it (toolSupport/localRuntime/healthCheck). Every consumer
+ * should treat it (toolSupport/localRuntime/healthCheck/inferenceKinds).
+ * Every consumer
  * that used to hand-maintain its own provider table (CLI choices,
  * CREDENTIAL_KEY_MAP, env-var checks, health-check dispatch, auto-select
  * priority, PROMPT_ONLY_TOOL_PROVIDERS) derives from PROVIDER_DESCRIPTORS
@@ -1902,6 +1945,20 @@ export type ProviderDescriptor = {
     name: AIProviderName;
     /** Alternate spellings accepted by the CLI and the alias index (kebab-case, shorthand, legacy names). Does not include `name` itself. */
     aliases: readonly string[];
+    /**
+     * Which inference types this provider actually serves. Omitted means
+     * `["generate", "stream"]`, which is what every text provider is — so every
+     * existing descriptor keeps its meaning untouched.
+     *
+     * This is the one declarative statement of a provider's modality. Before it
+     * existed, modality was only implied (by `toolSupport`, `healthCheck` and
+     * the auto-select ranks), which is why embedding-only providers like Voyage
+     * and Jina have to implement `getAISDKModel()` as a throw: nothing could
+     * express that they are not text providers. Consumers that build a
+     * generation fallback chain, run the health sweep, or offer CLI model
+     * choices should filter on this rather than special-case a provider name.
+     */
+    inferenceKinds?: readonly InferenceKind[];
     /** Key into NeurolinkCredentials for per-call/per-instance credential overrides. */
     credentialsKey: keyof NeurolinkCredentials;
     /** Environment variables this provider reads at runtime. */
@@ -1959,6 +2016,7 @@ export type ProviderDescriptor = {
     timeouts?: {
         generateMs?: number;
         streamMs?: number;
+        decideMs?: number;
     };
     /** Ascending priority (1 = tried first) in the auto-select fallback chain used by getBestProvider(). Undefined = not part of the auto-select chain. */
     autoSelectPriority?: number;

package/dist/types/providers.js

@@ -109,3 +109,8 @@ export const DEFAULT_PROVIDER_CONFIGS = [
         models: [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI],
     },
 ];
+/** What a descriptor means when it declares no `inferenceKinds`. */
+export const DEFAULT_INFERENCE_KINDS = [
+    "generate",
+    "stream",
+];

package/dist/types/rag.d.ts

@@ -1,5 +1,6 @@
 import type { Tool } from "./tools.js";
 import type { EmbedInput } from "./providers.js";
+import type { DecisionCallerFn } from "./decision.js";
 /**
  * RAG Type Definitions
  *
@@ -234,6 +235,16 @@ export type RAGPipelineConfig = {
     rerankingModel?: EmbeddingModelConfig;
     /** Multi-modal RAG configuration (image + text embeddings) */
     multiModal?: MultiModalRAGConfig;
+    /**
+     * Fail-open decision caller — typically a bound `NeuroLink.tryDecide`.
+     *
+     * When supplied AND a decision provider is configured, each query gets its
+     * own retrieval plan (`topK`, `hybrid`, `graph`, `rerank`) instead of the
+     * four static config values. An explicit per-call `QueryOptions` field
+     * always wins, and a capability this config did not enable can never be
+     * turned on by the plan.
+     */
+    decide?: DecisionCallerFn;
 };
 /**
  * Ingestion options
@@ -272,6 +283,12 @@ export type QueryOptions = {
     systemPrompt?: string;
     /** Temperature for generation */
     temperature?: number;
+    /**
+     * Set false to skip per-query retrieval planning even when a decision
+     * provider is configured. Fields passed explicitly here already override
+     * the plan, so this is for turning the extra round trip off entirely.
+     */
+    plan?: boolean;
 };
 /**
  * Query response
@@ -294,6 +311,8 @@ export type RAGResponse = {
         retrievalMethod: string;
         chunksRetrieved: number;
         reranked: boolean;
+        /** The per-query retrieval plan, when one was decided. */
+        plan?: SearchPlanResult;
     };
 };
 /**
@@ -1474,3 +1493,32 @@ export type ImageLoaderOptions = {
     /** Custom headers for URL fetches */
     headers?: Record<string, string>;
 };
+/**
+ * What a pipeline is *able* to do, handed to the per-search planner so it
+ * never suggests a capability that is not configured.
+ */
+export type SearchPlanCapabilities = {
+    /** The configured topK a breadth reading is scaled against. */
+    defaultTopK: number;
+    canHybrid: boolean;
+    canGraph: boolean;
+    canRerank: boolean;
+    /** Per-call timeout override for the decision request. */
+    timeoutMs?: number;
+};
+/**
+ * A suggested retrieval plan for one query. Every field is optional and means
+ * "use this unless the caller passed an explicit option".
+ */
+export type SearchPlanResult = {
+    topK?: number;
+    hybrid?: boolean;
+    graph?: boolean;
+    rerank?: boolean;
+    /** Index into the breadth rubric the topK was derived from. */
+    breadthLevel?: number;
+    /** Resolved decision model id, for telemetry. */
+    model: string;
+    /** Round trip in milliseconds. */
+    latencyMs: number;
+};

package/dist/types/span.d.ts

@@ -15,6 +15,17 @@ export declare enum SpanType {
     TOOL_CALL = "tool.call",
     /** LLM generation request */
     MODEL_GENERATION = "model.generation",
+    /**
+     * Decision-model request (the `decide` inference type).
+     *
+     * Deliberately NOT folded into MODEL_GENERATION. A decision emits no text,
+     * so it has no output tokens, no finish reason and a latency distribution
+     * roughly an order of magnitude tighter; counting it as a generation would
+     * distort generation counts, p50/p95 latency and the output-token
+     * aggregate simultaneously, and would make a cost dashboard attribute
+     * fractions of a cent to the same bucket as a frontier model.
+     */
+    MODEL_DECISION = "model.decision",
     /** Embedding generation (reserved for future embedding API) */
     EMBEDDING = "embedding",
     /** Retrieval operation (reserved for future RAG support) */

package/dist/types/span.js

@@ -16,6 +16,17 @@ export var SpanType;
     SpanType["TOOL_CALL"] = "tool.call";
     /** LLM generation request */
     SpanType["MODEL_GENERATION"] = "model.generation";
+    /**
+     * Decision-model request (the `decide` inference type).
+     *
+     * Deliberately NOT folded into MODEL_GENERATION. A decision emits no text,
+     * so it has no output tokens, no finish reason and a latency distribution
+     * roughly an order of magnitude tighter; counting it as a generation would
+     * distort generation counts, p50/p95 latency and the output-token
+     * aggregate simultaneously, and would make a cost dashboard attribute
+     * fractions of a cent to the same bucket as a frontier model.
+     */
+    SpanType["MODEL_DECISION"] = "model.decision";
     /** Embedding generation (reserved for future embedding API) */
     SpanType["EMBEDDING"] = "embedding";
     /** Retrieval operation (reserved for future RAG support) */

package/dist/types/stream.d.ts

@@ -293,6 +293,19 @@ export type ExecutionControlOptions = {
     beforeStepTimeoutMs?: number;
 };
 export type StreamOptions = {
+    /**
+     * Fraction of the model's context window at which compaction runs for this
+     * request, replacing the 0.8 default.
+     *
+     * A request that needs only the current message does not need the whole
+     * window kept warm for it, and compacting earlier is free; a request that
+     * depends on the entire conversation should compact as late as possible.
+     * When the classifier router runs with a decision model it fills this in
+     * per request — always at or below the default, never above, because a
+     * request that overflows the window fails hard and `ModelPool` records that
+     * failure as a permanent cooldown.
+     */
+    compactionThreshold?: number;
     /**
      * Opt this stream call into the knowledge grounding configured on the
      * NeuroLink instance. Defaults to `false` when omitted.

package/dist/types/toolRouting.d.ts

@@ -16,6 +16,7 @@
  * identical to routing being disabled.
  */
 import type { GenerateOptions, GenerateResult } from "./generate.js";
+import type { DecisionCallerFn } from "./decision.js";
 /** One routable server as declared by the host application. */
 export type ToolRoutingServerDescriptor = {
     /**
@@ -171,6 +172,17 @@ export type ToolRoutingConfig = {
      *   off (or fails) the granularity falls back to `"server"` automatically.
      */
     granularity?: "server" | "tool";
+    /**
+     * How confidently a decision model must rule a server OUT before its tools
+     * are withheld. Default 0.6.
+     *
+     * Only consulted when a decision provider is configured, in which case one
+     * calibrated yes/no question per server replaces the generative router. The
+     * bar is deliberately asymmetric and high: keeping an unneeded server costs
+     * a few hundred tokens, while dropping a needed one costs the turn, because
+     * the model cannot call — or even ask for — a tool it was never shown.
+     */
+    minDropConfidence?: number;
 };
 /** Catalog entry pairing a server descriptor with its registered tool names. */
 export type ToolRoutingCatalogEntry = {
@@ -248,6 +260,12 @@ export type ToolRoutingDecision = {
      * applied (outcome === "applied").
      */
     granularity?: "server" | "tool";
+    /**
+     * Which strategy produced this decision. Absent on skip/fail-open paths that
+     * never reached one. "decision" is the calibrated per-server router,
+     * "embedding" the L2 retriever, "llm" the generative router.
+     */
+    strategy?: "decision" | "embedding" | "llm";
 };
 /** Parameters for `resolveToolRoutingExclusions()`. */
 export type ToolRoutingResolutionParams = {
@@ -265,6 +283,25 @@ export type ToolRoutingResolutionParams = {
     timeoutMs: number;
     /** Invokes the router LLM — `NeuroLink.generate` bound by the caller. */
     generateFn: (options: GenerateOptions) => Promise<GenerateResult>;
+    /**
+     * Invokes a decision model — `NeuroLink.tryDecide` bound by the caller.
+     * When supplied AND a decision provider is configured, one yes/no question
+     * per server replaces the router LLM call: ~400ms and ~$0.00002 instead of
+     * a generative call on a 15-second budget, and a calibrated probability per
+     * server instead of a list that cannot express doubt.
+     *
+     * Omitting it reproduces the LLM-only behaviour exactly, and so does
+     * supplying it with no decision provider configured — the caller's bound
+     * `tryDecide` returns null and the LLM path runs.
+     */
+    decideFn?: DecisionCallerFn;
+    /**
+     * How confidently the decision router must answer "no" before a server's
+     * tools are withheld. Default 0.6. Deliberately asymmetric: a wrongly
+     * dropped server breaks the turn, a wrongly kept one costs a few hundred
+     * tokens.
+     */
+    decisionMinDropConfidence?: number;
     /**
      * Optional callback invoked once per resolution with a structured summary of
      * the routing decision. Called on every return path (applied, skipped,
@@ -348,3 +385,22 @@ export type ToolRetrievalSelectOptions = {
      */
     timeoutMs?: number;
 };
+/**
+ * What the decision-model tool router concluded. Distinct from
+ * {@link ToolRoutingDecision}, which is the telemetry record for a routing
+ * turn regardless of which strategy produced it.
+ */
+export type ToolRoutingDecisionOutcome = {
+    /** Servers whose tools stay available. */
+    selectedServerIds: string[];
+    /** Servers the model confidently ruled out. */
+    excludedServerIds: string[];
+    /** Flattened tool names to add to the request denylist. */
+    excludedToolNames: string[];
+    /** How many servers came back with a usable, confident answer. */
+    answeredCount: number;
+    /** Resolved decision model id, for telemetry. */
+    model: string;
+    /** Round trip in milliseconds. */
+    latencyMs: number;
+};

package/dist/utils/decisionAnswers.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Readers for a decision model's answer map.
+ *
+ * Every reader validates at runtime and returns `undefined` for a missing id
+ * **or** a type mismatch, so no call site needs a type assertion (CLAUDE.md
+ * rule 14) and "no opinion" stays distinguishable from "an opinion of 0".
+ *
+ * @module utils/decisionAnswers
+ */
+import type { DecisionAnswerMap, DecisionBooleanGate, DecisionChoiceReading, DecisionScoreReading, ProviderDescriptor } from "../types/index.js";
+/**
+ * Read a yes/no answer as a probability.
+ *
+ * Returns undefined when the id is absent or the answer was a different
+ * type — a caller can therefore tell "not answered" from "answered 0".
+ */
+export declare function readDecisionBoolean(answers: DecisionAnswerMap, id: string): number | undefined;
+/**
+ * Read a choice answer, including the full ranking.
+ *
+ * `ranked` is the distribution sorted highest-first. This is what makes one
+ * choice question over N options a ranking of all N — the basis for picking
+ * from a large catalogue in a single request.
+ */
+export declare function readDecisionChoice(answers: DecisionAnswerMap, id: string): DecisionChoiceReading | undefined;
+export declare function readDecisionScore(answers: DecisionAnswerMap, id: string): DecisionScoreReading | 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
+ * 0 or 1 → 1.
+ */
+export declare function decisionBooleanConfidence(probability: number): number;
+/** Whether a descriptor declares support for a given inference type. */
+export declare function servesInferenceKind(descriptor: Pick<ProviderDescriptor, "inferenceKinds">, kind: "generate" | "stream" | "decide"): boolean;
+/**
+ * Read a yes/no answer as an actionable decision, or `undefined` when there
+ * is not enough signal to act.
+ *
+ * Three outcomes, and keeping them distinct is the whole point: `true` (a
+ * confident yes), `false` (a confident no), and `undefined` (unanswered, the
+ * wrong type, or too close to a coin flip). Every consumer of the `decide`
+ * inference type needs exactly this, so the bars live here rather than being
+ * re-invented — inconsistently — at each call site.
+ */
+export declare function gateDecisionBoolean(answers: DecisionAnswerMap, id: string, gate?: DecisionBooleanGate): boolean | undefined;
+/**
+ * Build a question id that survives a round trip.
+ *
+ * Question ids are the only thing tying an answer back to what it was asked
+ * about, and a batch mixes heterogeneous questions (one per server, one per
+ * message, plus gates), so the namespace prefix is what demultiplexes them.
+ * The index — not the subject's own name — is the key, because ids from the
+ * wild (server ids, model ids, file paths) are not guaranteed to be distinct
+ * after any normalisation the wire might apply.
+ */
+export declare function decisionKey(namespace: string, index: number): string;

package/dist/utils/decisionAnswers.js

@@ -0,0 +1,95 @@
+/**
+ * Readers for a decision model's answer map.
+ *
+ * Every reader validates at runtime and returns `undefined` for a missing id
+ * **or** a type mismatch, so no call site needs a type assertion (CLAUDE.md
+ * rule 14) and "no opinion" stays distinguishable from "an opinion of 0".
+ *
+ * @module utils/decisionAnswers
+ */
+import { DEFAULT_INFERENCE_KINDS } from "../types/index.js";
+/**
+ * Read a yes/no answer as a probability.
+ *
+ * Returns undefined when the id is absent or the answer was a different
+ * type — a caller can therefore tell "not answered" from "answered 0".
+ */
+export function readDecisionBoolean(answers, id) {
+    const answer = answers[id];
+    return answer?.type === "boolean" ? answer.probability : undefined;
+}
+/**
+ * Read a choice answer, including the full ranking.
+ *
+ * `ranked` is the distribution sorted highest-first. This is what makes one
+ * choice question over N options a ranking of all N — the basis for picking
+ * from a large catalogue in a single request.
+ */
+export function readDecisionChoice(answers, id) {
+    const answer = answers[id];
+    if (answer?.type !== "choice") {
+        return undefined;
+    }
+    const { choice, confidence, probabilities } = answer;
+    const ranked = Object.entries(probabilities)
+        .map(([name, probability]) => ({ name, probability }))
+        .sort((a, b) => b.probability - a.probability);
+    return { choice, confidence, probabilities, ranked };
+}
+export function readDecisionScore(answers, id) {
+    const answer = answers[id];
+    if (answer?.type !== "score") {
+        return undefined;
+    }
+    const { score, confidence, legend, probabilities } = answer;
+    return { score, confidence, legend, probabilities };
+}
+/**
+ * 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
+ * 0 or 1 → 1.
+ */
+export function decisionBooleanConfidence(probability) {
+    return Math.abs(probability - 0.5) * 2;
+}
+/** Whether a descriptor declares support for a given inference type. */
+export function servesInferenceKind(descriptor, kind) {
+    return (descriptor.inferenceKinds ?? DEFAULT_INFERENCE_KINDS).includes(kind);
+}
+/** Default bars for {@link gateDecisionBoolean}. */
+const DEFAULT_BOOLEAN_MIN_PROBABILITY = 0.5;
+const DEFAULT_BOOLEAN_MIN_CONFIDENCE = 0.4;
+/**
+ * Read a yes/no answer as an actionable decision, or `undefined` when there
+ * is not enough signal to act.
+ *
+ * Three outcomes, and keeping them distinct is the whole point: `true` (a
+ * confident yes), `false` (a confident no), and `undefined` (unanswered, the
+ * wrong type, or too close to a coin flip). Every consumer of the `decide`
+ * inference type needs exactly this, so the bars live here rather than being
+ * re-invented — inconsistently — at each call site.
+ */
+export function gateDecisionBoolean(answers, id, gate) {
+    const probability = readDecisionBoolean(answers, id);
+    if (probability === undefined) {
+        return undefined;
+    }
+    const minConfidence = gate?.minConfidence ?? DEFAULT_BOOLEAN_MIN_CONFIDENCE;
+    if (decisionBooleanConfidence(probability) < minConfidence) {
+        return undefined;
+    }
+    return (probability >= (gate?.minProbability ?? DEFAULT_BOOLEAN_MIN_PROBABILITY));
+}
+/**
+ * Build a question id that survives a round trip.
+ *
+ * Question ids are the only thing tying an answer back to what it was asked
+ * about, and a batch mixes heterogeneous questions (one per server, one per
+ * message, plus gates), so the namespace prefix is what demultiplexes them.
+ * The index — not the subject's own name — is the key, because ids from the
+ * wild (server ids, model ids, file paths) are not guaranteed to be distinct
+ * after any normalisation the wire might apply.
+ */
+export function decisionKey(namespace, index) {
+    return `${namespace}__${index}`;
+}

package/dist/utils/modelChoices.js

@@ -2,7 +2,7 @@
  * Centralized model choices for CLI commands
  * Derives choices from model enums to ensure consistency
  */
-import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, HuggingFaceModels, SageMakerModels, OpenRouterModels, DeepSeekModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
+import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, HuggingFaceModels, SageMakerModels, OpenRouterModels, DeepSeekModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, ReplicateModels, } from "../constants/enums.js";
 import { getCatalogJsonEntries } from "../providers/catalog/loader.js";
 /**
  * Looks up the JSON catalog entry for a provider, if it is one of the 9
@@ -393,6 +393,16 @@ const TOP_MODELS_CONFIG = {
         },
         { model: RecraftModels.RECRAFT_V2, description: "V2" },
     ],
+    [AIProviderName.TYPESAFE]: [
+        {
+            model: TypeSafeModels.JEV_LATEST,
+            description: "Recommended - Jev (decisions, not text)",
+        },
+        {
+            model: TypeSafeModels.JEV_PREVIEW,
+            description: "Preview build of Jev",
+        },
+    ],
     [AIProviderName.AUTO]: [],
 };
 /**
@@ -432,6 +442,7 @@ export const DEFAULT_MODELS = {
     [AIProviderName.STABILITY]: StabilityModels.STABLE_IMAGE_ULTRA,
     [AIProviderName.IDEOGRAM]: IdeogramModels.IDEOGRAM_V3,
     [AIProviderName.RECRAFT]: RecraftModels.RECRAFT_V3,
+    [AIProviderName.TYPESAFE]: TypeSafeModels.JEV_LATEST,
 };
 /**
  * Model enum mappings for getAllModels.
@@ -464,6 +475,7 @@ const MODEL_ENUMS = {
     [AIProviderName.STABILITY]: StabilityModels,
     [AIProviderName.IDEOGRAM]: IdeogramModels,
     [AIProviderName.RECRAFT]: RecraftModels,
+    [AIProviderName.TYPESAFE]: TypeSafeModels,
     [AIProviderName.AUTO]: null,
 };
 /**

package/dist/utils/pricing.js

@@ -634,6 +634,17 @@ const PRICING = {
             output: 0,
         },
     },
+    typesafe: {
+        // TypeSafe bills per million INPUT tokens only. Output is REPORTED but
+        // not billed: measured live, a decision returns roughly 17 output tokens
+        // per question (1 question → 21, 20 questions → 354), and the rate on
+        // them is zero. So `output: 0` is a price, not a token count — do not
+        // "correct" it by reading a non-zero `usage.output_tokens` off a
+        // response. A three-question decision costs ~$0.000013 in total.
+        // Rates from typesafe.ai/pricing (checked 2026-09-20).
+        _default: { input: 0.042 / 1_000_000, output: 0 },
+        "jev-latest": { input: 0.042 / 1_000_000, output: 0 },
+    },
     stability: {
         // Stability AI bills per image; symbolic per-token rate.
         _default: { input: 0, output: 0.04 / 1_000 },

package/dist/utils/providerConfig.d.ts

@@ -396,3 +396,7 @@ export declare function resolveOpenAICompatConfig(entry: OpenAICompatConfigInput
     apiKey: string;
     baseURL: string;
 };
+/**
+ * TypeSafe (Jev) — the `decide` inference type. Not a text provider.
+ */
+export declare function createTypeSafeConfig(): ProviderConfigOptions;

package/dist/utils/providerConfig.js

@@ -1307,3 +1307,20 @@ export function resolveOpenAICompatConfig(entry, credentials) {
     }
     return { apiKey, baseURL };
 }
+/**
+ * TypeSafe (Jev) — the `decide` inference type. Not a text provider.
+ */
+export function createTypeSafeConfig() {
+    return {
+        providerName: "TypeSafe (Jev)",
+        envVarName: "TYPESAFE_API_KEY",
+        setupUrl: "https://console.typesafe.ai/keys",
+        description: "API key",
+        instructions: [
+            "1. Visit: https://console.typesafe.ai/keys",
+            "2. Sign in to your TypeSafe account",
+            "3. Create a new API key",
+            "4. Set TYPESAFE_API_KEY in your .env file",
+        ],
+    };
+}