@juspay/neurolink 12.18.0 → 12.19.0

package/dist/types/classifierRouter.d.ts

@@ -14,10 +14,29 @@
  * `src/lib/types/` (see CLAUDE.md rule 9).
  */
 import type { ValidationSchema } from "./aliases.js";
+import type { DecisionCallerFn } from "./decision.js";
 /** Coarse difficulty buckets the classifier maps a request into. */
 export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
-/** Which classification strategy to run. */
-export type ClassifierStrategyKind = "heuristic" | "llm";
+/**
+ * Which classification strategy to run.
+ *
+ * - `heuristic` — keyword/length scoring. Deterministic, zero latency.
+ * - `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`.
+ */
+export type ClassifierStrategyKind = "heuristic" | "llm" | "jev" | "auto";
+/**
+ * How much of the available context a request actually needs, ordered
+ * narrowest → widest. This is a *rubric*, not a token count: a decision model
+ * is reliable at placing a request on an ordered scale and unreliable at
+ * naming a number (it reads digits as text, not as quantities).
+ *
+ * The index is mapped onto a compaction threshold by the router, and only
+ * ever downward — see `ClassifierRouterDecision.compactionThreshold`.
+ */
+export type ClassifierContextScope = "current-message" | "recent-turns" | "full-conversation" | "everything";
 /**
  * The classifier's verdict for a single request. Strategy-agnostic: produced
  * by both the heuristic and the LLM classifier.
@@ -36,6 +55,27 @@ export type ClassifierDecision = {
      * (matches a `ClassifierCandidate.id`). Ignored by the heuristic classifier.
      */
     selectedModelId?: string;
+    /**
+     * Confidence in `selectedModelId`, when the strategy reports one.
+     *
+     * Separate from `confidence`, which is about the DIFFICULTY verdict: a
+     * classifier can be certain a task is hard and unsure which model suits it.
+     * The router needs this one on its own, because whether a pick must clear
+     * the upgrade bar or the downgrade bar depends on the pick, not the tier.
+     *
+     * Absent means the strategy does not report one (the LLM classifier), in
+     * which case the pick is honoured as it always was.
+     */
+    selectedModelConfidence?: number;
+    /**
+     * How much context the request needs. Only the decision strategy produces
+     * this — the heuristic has no way to judge it and the LLM classifier is not
+     * asked, since for it every extra field costs output tokens. For a decision
+     * model the question is very nearly free.
+     */
+    contextScope?: ClassifierContextScope;
+    /** Confidence in `contextScope`, 0-1. Calibrated for the decide strategy. */
+    contextScopeConfidence?: number;
     /** Human-readable explanation, emitted at debug level. */
     reason?: string;
 };
@@ -50,6 +90,46 @@ export type ClassifierCandidate = {
     description?: string;
     tiers?: ClassifierDifficulty[];
     capabilities?: string[];
+    /**
+     * Maximum input window, in tokens. Read from the model registry when the
+     * pool is built from the catalogue. Nothing in routing consulted this
+     * before — a request was routed to a model without ever asking whether it
+     * could hold the request.
+     */
+    contextWindow?: number;
+    /** USD per 1K input tokens, for the cheapest-that-works judgement. */
+    inputCostPer1K?: number;
+    /** USD per 1K output tokens. */
+    outputCostPer1K?: number;
+    /** Registry speed bucket ("fast" | "medium" | "slow"). */
+    speed?: string;
+    /** Registry quality bucket ("high" | "medium" | "low"). */
+    quality?: string;
+    /**
+     * The registry's per-dimension suitability scores (1–10): coding, analysis,
+     * reasoning, conversation, creative, translation, summarization. Present
+     * only for registry-backed models.
+     */
+    useCases?: Readonly<Record<string, number>>;
+    /**
+     * Deterministic merit score for the difficulty this candidate was built
+     * for, higher is better. Computed by `enrichCandidate`; it is what the
+     * fallback ranker sorts on and is never sent to the model.
+     */
+    score?: number;
+    /**
+     * The host's own `cost` / `quality` from the pool member, if it declared
+     * them. These are RELATIVE scales, comparable only against other members
+     * of the same pool — never a currency and never a registry bucket.
+     *
+     * They are carried separately because they take precedence over anything
+     * the registry says. A host that writes `quality: 2` next to "cheap and
+     * fast; rote edits only" has made a statement about how it wants that
+     * model used, and the registry — which may rate the same model highly on
+     * its own general benchmarks — does not get to overrule it.
+     */
+    relativeCost?: number;
+    relativeQuality?: number;
 };
 /**
  * One candidate (provider, model, region) in the available base pool, with
@@ -102,12 +182,26 @@ export type ClassifierRouterConfig = {
     /** Master switch. When false/absent, the router is never built. */
     enabled: boolean;
     /**
-     * Classification strategy. Default: "heuristic" (no LLM, zero added latency).
-     * "llm" runs a cheap classifier model (see `classifierModel`).
+     * Classification strategy. Default: "auto" — which resolves to "jev" when
+     * `TYPESAFE_API_KEY` is set and "heuristic" otherwise, so configuring a key
+     * upgrades routing without any code change. Behaviour for callers with no
+     * key is unchanged.
      */
     classifier?: ClassifierStrategyKind;
     /** Model used by the "llm" strategy. Defaults to provider/model auto. */
     classifierModel?: ClassifierModelRef;
+    /**
+     * How sure the classifier must be to route a request UP to a more capable
+     * (costlier) model. Being wrong here costs money, so the bar is low.
+     * Only meaningful for "jev", whose confidence is calibrated. Default: 0.3.
+     */
+    minUpgradeConfidence?: number;
+    /**
+     * How sure it must be to route DOWN to a cheaper model. Being wrong here
+     * means a task handled by too small a model, so the bar is high.
+     * Default: 0.6.
+     */
+    minDowngradeConfidence?: number;
     /** The available base pool the router selects a model from. */
     pool: ClassifierRouterPoolMember[];
     /**
@@ -119,6 +213,46 @@ export type ClassifierRouterConfig = {
     toolDirectives?: Partial<Record<ClassifierDifficulty, ClassifierToolDirective>>;
     /** Hard timeout (ms) for the LLM classifier call. Default: 8000. */
     timeoutMs?: number;
+    /**
+     * Widen the pool with every model the registry knows about that this host
+     * actually has credentials for.
+     *
+     * Off by default, and deliberately so: the declared `pool` is a statement
+     * about which models a host is *willing* to be billed for, and NeuroLink
+     * cannot invent that. Turning this on says "anything I have a key for is
+     * fair game", which is exactly right for a CLI and exactly wrong for a
+     * service with a negotiated model list.
+     */
+    catalog?: ClassifierCatalogConfig;
+    /**
+     * Ask the classifier how much context the request needs and use the answer
+     * to lower the compaction threshold. Default: true when the strategy
+     * resolves to a decision model, since the question rides along in a batch
+     * that is already being sent. Ignored by the other strategies.
+     */
+    contextBudget?: boolean;
+};
+/** How the model catalogue widens the declared pool. */
+export type ClassifierCatalogConfig = {
+    enabled: boolean;
+    /**
+     * Cap on catalogue-derived members. The binding constraint is the decision
+     * model's input ceiling — state plus the longest single question must stay
+     * under ~33K tokens, and the model question's `criteria` map is that
+     * question. At roughly 40 tokens per rendered model that ceiling is
+     * hundreds of models away.
+     *
+     * Default: 120. The registry currently holds 64 models, so the default
+     * never truncates today — it is a guard against a future registry that
+     * grows past what one question can carry, not a limit anyone is hitting.
+     */
+    maxModels?: number;
+    /** Restrict the catalogue to these provider names. Omit for all configured. */
+    providers?: string[];
+    /** Drop models whose context window is below this. Default: 0 (keep all). */
+    minContextWindow?: number;
+    /** Include models flagged deprecated in the registry. Default: false. */
+    includeDeprecated?: boolean;
 };
 /**
  * The router's combined decision: a provider/model/region override plus an
@@ -135,6 +269,20 @@ export type ClassifierRouterDecision = {
     excludeTools?: string[];
     /** The difficulty this decision was made for (debug/telemetry). */
     difficulty?: ClassifierDifficulty;
+    /**
+     * Fraction of the model's window at which compaction should trigger for
+     * THIS request, replacing the fixed 0.8 default.
+     *
+     * **Only ever lower than the default, never higher.** Raising it would let
+     * a request through that the model then rejects with a context-window
+     * error — and `ModelPool` treats that as a permanent cooldown (10 years),
+     * so a single optimistic guess retires the model for the life of the
+     * process. Shrinking a budget wastes a little context; growing one is
+     * unrecoverable.
+     */
+    compactionThreshold?: number;
+    /** The scope reading `compactionThreshold` was derived from. */
+    contextScope?: ClassifierContextScope;
     /** Remaining ranked candidates, best-first, for downstream failover. */
     modelFallbacks?: ClassifierRouterPoolMember[];
     /** Human-readable explanation, emitted at debug level. */
@@ -178,6 +326,12 @@ export type ClassifierGenerateResult = {
 };
 /** Injected LLM caller — typically a bound `NeuroLink.generate`. */
 export type ClassifierGenerateFn = (options: ClassifierGenerateOptions) => Promise<ClassifierGenerateResult>;
+/**
+ * Injected decision caller — typically a bound `NeuroLink.tryDecide`, which
+ * returns null on any failure. Keeps `ClassifierRouter` free of provider
+ * imports, exactly as `ClassifierGenerateFn` does.
+ */
+export type ClassifierDecideFn = DecisionCallerFn;
 /** Minimal logger surface the router uses (debug/warn). */
 export type ClassifierLogger = {
     debug: (message: string, meta?: unknown) => void;
@@ -190,5 +344,7 @@ export type ClassifierLogger = {
 export type ClassifierRouterDeps = {
     /** LLM caller for the "llm" strategy. Omit to disable LLM classification. */
     generate?: ClassifierGenerateFn;
+    /** Decision caller for the "jev" strategy. Omit to disable it. */
+    decide?: ClassifierDecideFn;
     logger?: ClassifierLogger;
 };

package/dist/types/cli.d.ts

@@ -1681,8 +1681,24 @@ export type CliToolRoutingFlags = {
 export type CliClassifierRouterFlags = {
     /** Master enable switch (--classifier-router). */
     classifierRouter?: boolean;
-    /** Strategy: "heuristic" (default) or "llm" (--classifier-strategy). */
+    /**
+     * Strategy: "auto" (default), "heuristic", "llm" or "jev"
+     * (--classifier-strategy). "auto" resolves to "jev" when TYPESAFE_API_KEY
+     * is set and "heuristic" otherwise.
+     */
     classifierStrategy?: string;
+    /**
+     * Minimum confidence required to route UP to a costlier model
+     * (--classifier-min-upgrade-confidence). Only meaningful for "jev", whose
+     * confidence is calibrated. Default: 0.3.
+     */
+    classifierMinUpgradeConfidence?: number;
+    /**
+     * Minimum confidence required to route DOWN to a cheaper model
+     * (--classifier-min-downgrade-confidence). Higher than the upgrade bar
+     * because the mistakes cost differently. Default: 0.6.
+     */
+    classifierMinDowngradeConfidence?: number;
     /** LLM-classifier provider override (--classifier-model-provider). */
     classifierModelProvider?: string;
     /** LLM-classifier model override (--classifier-model-name). */

package/dist/types/config.d.ts

@@ -13,6 +13,7 @@ import type { NeurolinkCredentials } from "./providers.js";
 import type { ModelPoolConfig } from "./modelPool.js";
 import type { RequestRouter } from "./requestRouter.js";
 import type { ClassifierRouterConfig } from "./classifierRouter.js";
+import type { ContextRelevanceOptions } from "./context.js";
 import type { SkillsConfig } from "./skills.js";
 import type { KnowledgeGroundingConfig } from "./knowledge.js";
 /**
@@ -143,6 +144,17 @@ export type NeurolinkConstructorConfig = {
      * caller pinned both `provider` and `model`. See {@link ClassifierRouterConfig}.
      */
     classifierRouter?: ClassifierRouterConfig;
+    /**
+     * Relevance-driven context compaction. When a decision provider is
+     * configured, compaction gains a stage-zero pass that drops the earlier
+     * messages the current request provably does not need, before the
+     * positional stages (which protect by recency alone) get to choose.
+     *
+     * This object only TUNES that stage; it does not enable it. The stage runs
+     * whenever a decision provider is configured, and does nothing otherwise,
+     * which is the same activation rule every other decision consumer uses.
+     */
+    contextRelevance?: ContextRelevanceOptions;
     /**
      * Native skills: versioned, discoverable instruction packs (SOPs,
      * playbooks) with progressive disclosure. When enabled, each

package/dist/types/context.d.ts

@@ -5,6 +5,7 @@
 import type { ExecutionContext } from "../types/tools.js";
 import type { JsonObject } from "./common.js";
 import type { ChatMessage, ConversationMemoryConfig } from "./conversation.js";
+import type { DecisionCallerFn } from "./decision.js";
 /**
  * Base context type for all AI operations
  */
@@ -173,7 +174,7 @@ export declare class ContextConverter {
     private static extractCustomData;
 }
 /** Stages available in the compaction pipeline. */
-export type CompactionStage = "prune" | "deduplicate" | "summarize" | "truncate";
+export type CompactionStage = "relevance" | "prune" | "deduplicate" | "summarize" | "truncate";
 /** Result of multi-stage context compaction. */
 export type CompactionResult = {
     compacted: boolean;
@@ -577,4 +578,57 @@ export type NativeGenerateGuardConfig = {
     availableInputTokens: number;
     getFixedOverheadTokens: () => number;
 };
+/** Tuning for the relevance stage of context compaction. */
+export type ContextRelevanceOptions = {
+    /** Trailing messages never eligible for dropping. Default 6. */
+    protectRecent?: number;
+    /** Confidence required to drop a message. Default 0.6. */
+    minDropConfidence?: number;
+    /** Ceiling on the share of eligible messages one pass may drop. Default 0.5. */
+    maxDropRatio?: number;
+    /** Per-call timeout override for the decision request. */
+    timeoutMs?: number;
+};
+/** What the relevance stage concluded. */
+export type ContextRelevanceResult = {
+    /** The surviving messages, in their original order. */
+    messages: ChatMessage[];
+    /** Indices into the ORIGINAL array that were dropped. */
+    droppedIndices: number[];
+    /** How many messages were asked about. */
+    askedCount: number;
+    /** How many came back with a usable, confident answer. */
+    answeredCount: number;
+    /** Resolved decision model id, for telemetry. */
+    model: string;
+    /** Round trip in milliseconds. */
+    latencyMs: number;
+};
+/**
+ * Injected dependencies for {@link ContextCompactor}.
+ *
+ * Deliberately separate from `CompactionConfig`: that type is spread into a
+ * `Required<CompactionConfig>` default, so a function member would need a
+ * default implementation, and the compactor must stay fully usable with no
+ * decision provider configured.
+ */
+export type ContextCompactorDeps = {
+    /** Fail-open decision caller. Omitted = the previous pipeline, exactly. */
+    decide?: DecisionCallerFn;
+    /** Tuning for the relevance stage. */
+    relevance?: ContextRelevanceOptions;
+    /** Tuning for the post-summarization quality gate. */
+    summaryGate?: {
+        timeoutMs?: number;
+        minConfidence?: number;
+    };
+};
+/** Per-call context handed to `ContextCompactor.compact`. */
+export type ContextCompactRequest = {
+    /**
+     * The request being prepared. Without it the relevance stage cannot run —
+     * "is this message still needed?" is meaningless without knowing what for.
+     */
+    currentRequest?: string;
+};
 export {};

package/dist/types/decision.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Decision inference types — typed, calibrated judgements from a model that
+ * emits no text.
+ *
+ * `decide` is the third inference type, alongside `generate` and `stream`. A
+ * decision model takes one `state` plus a map of named typed questions and
+ * returns one typed answer per question, all evaluated in a single parallel
+ * pass. TypeSafe's Jev is the first such model; Vercel's AI SDK models the
+ * same class separately from `LanguageModelV4`, for the same reason.
+ *
+ * The vocabulary here is deliberately **provider-neutral**. TypeSafe calls a
+ * yes/no question a `noul` and answers it in a field of the same name; both
+ * the Vercel AI SDK and Pydantic AI independently renamed that to `boolean` /
+ * `probability` when exposing it. This file follows them, and the mapping to
+ * a vendor's wire format belongs in that vendor's provider.
+ *
+ * Names are domain-prefixed `Decision*` to stay globally unique across
+ * `src/lib/types/` (CLAUDE.md rule 9). Note `evaluate`/`Evaluation*` is a
+ * different, unrelated feature — scoring a generated response with RAGAS.
+ */
+import type { NeurolinkCredentials } from "./providers.js";
+/**
+ * Anything a decision model accepts as free-form content. `state` may be a
+ * plain string or structured JSON (chat logs, records); `instructions` and
+ * `criteria` values likewise.
+ */
+export type DecisionInput = string | number | boolean | readonly DecisionInput[] | {
+    readonly [key: string]: DecisionInput;
+};
+/** The content being judged. One shared state per request. */
+export type DecisionState = DecisionInput;
+/**
+ * A yes/no question. Answered with a probability and **no confidence of its
+ * own** — gate it on distance from 0.5 via {@link decisionBooleanConfidence}.
+ */
+export type DecisionBooleanQuestion = {
+    type: "boolean";
+    instructions: DecisionInput;
+    /** Optional descriptions of what a yes and a no mean. */
+    criteria?: {
+        true?: DecisionInput | null;
+        false?: DecisionInput | null;
+    };
+};
+/**
+ * Pick one option. `criteria` maps option name → rubric description.
+ *
+ * The answer carries the full probability distribution, not just the winner,
+ * so a single choice question over N options also **ranks** all N.
+ */
+export type DecisionChoiceQuestion = {
+    type: "choice";
+    instructions: DecisionInput;
+    criteria: Readonly<Record<string, DecisionInput | null>>;
+};
+/**
+ * Rate against an ordered rubric. The answer is the **0-based index**, so a
+ * four-level rubric scores 0–3. At least two levels are required.
+ */
+export type DecisionScoreQuestion = {
+    type: "score";
+    instructions: DecisionInput;
+    criteria: readonly (DecisionInput | null)[];
+};
+export type DecisionQuestion = DecisionBooleanQuestion | DecisionChoiceQuestion | DecisionScoreQuestion;
+/** Questions keyed by an id you choose; answers return under the same ids. */
+export type DecisionQuestionMap = Readonly<Record<string, DecisionQuestion>>;
+export type DecisionBooleanAnswer = {
+    type: "boolean";
+    /** Probability the statement is true, 0–1. */
+    probability: number;
+};
+export type DecisionChoiceAnswer = {
+    type: "choice";
+    /** The highest-probability option name. */
+    choice: string;
+    /** Every option mapped to its probability. Key order is not stable. */
+    probabilities: Readonly<Record<string, number>>;
+    /** Calibrated certainty, 0–1, derived from the distribution. */
+    confidence: number;
+};
+export type DecisionScoreAnswer = {
+    type: "score";
+    /** Probability-weighted level index; lands between levels. */
+    score: number;
+    /** Level index (as a string key) → the description supplied. */
+    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 DecisionAnswerMap = Readonly<Record<string, DecisionAnswer>>;
+export type DecisionUsage = {
+    inputTokens: number;
+    outputTokens: number;
+};
+export type DecisionRequest = {
+    state: DecisionState;
+    questions: DecisionQuestionMap;
+    /** Overrides the provider's configured model for this call only. */
+    model?: string;
+    signal?: AbortSignal;
+    /** Overrides the configured timeout for this call only. */
+    timeoutMs?: number;
+};
+export type DecisionResult = {
+    /** The RESOLVED model id (e.g. "jev-1.13.0"), not the alias sent. */
+    model: string;
+    provider: string;
+    answers: DecisionAnswerMap;
+    usage: DecisionUsage;
+    /** Vendor request id, for support escalation. */
+    requestId?: string;
+    /** Wall-clock round trip measured client-side. */
+    latencyMs: number;
+    /** Server-side time behind the edge; isolates model time from network. */
+    upstreamMs?: number;
+};
+/**
+ * Why a decision call failed, normalised across vendors. TypeSafe alone
+ * returns two different error envelopes, so a provider must flatten them.
+ */
+export type DecisionErrorKind = "authentication" | "invalid_request" | "max_tokens_exceeded" | "rate_limit" | "overloaded" | "server" | "timeout" | "network";
+export type DecisionError = {
+    kind: DecisionErrorKind;
+    message: string;
+    status?: number;
+    requestId?: string;
+    /** True when a retry could plausibly succeed. */
+    retryable: boolean;
+};
+/** One entry from a decision provider's model listing. */
+export type DecisionModelCard = {
+    name: string;
+    description: string;
+    releaseDate: string;
+};
+/**
+ * Narrowed view of a choice answer, safe to consume without re-narrowing.
+ * Returned by the reader helpers so call sites need no type assertion.
+ */
+export type DecisionChoiceReading = {
+    choice: string;
+    confidence: number;
+    probabilities: Readonly<Record<string, number>>;
+    /**
+     * Every option ordered by probability, highest first. A choice question is
+     * therefore also a ranking — the basis for catalogue selection.
+     */
+    ranked: readonly {
+        name: string;
+        probability: number;
+    }[];
+};
+export type DecisionScoreReading = {
+    score: number;
+    confidence: number;
+    legend: Readonly<Record<string, string>>;
+    probabilities: Readonly<Record<string, number>>;
+};
+/**
+ * What `NeuroLink.decide()` accepts: a decision request plus the usual
+ * provider/credential selection every inference type shares.
+ */
+export type DecisionOptions = DecisionRequest & {
+    /**
+     * Provider name or alias. Defaults to the first registered provider whose
+     * descriptor declares `"decide"` in `inferenceKinds`.
+     */
+    provider?: string;
+    /** Per-call credential overrides, as `generate()` takes. */
+    credentials?: NeurolinkCredentials;
+};
+/**
+ * Injected fail-open decision caller — typically a bound `NeuroLink.tryDecide`,
+ * which returns `null` on any failure rather than throwing.
+ *
+ * Every internal consumer of the `decide` inference type takes one of these
+ * instead of importing a provider, exactly as the tool router takes a
+ * `generateFn`. It is what keeps the consumers provider-import-free, and what
+ * makes "no decision provider configured" indistinguishable from "the call
+ * failed" at every call site: both are `null`, and both mean *carry on as
+ * before*.
+ */
+export type DecisionCallerFn = (options: DecisionOptions) => Promise<DecisionResult | null>;
+/**
+ * Shared gate for acting on a yes/no answer.
+ *
+ * A `boolean` answer carries no confidence of its own, so two separate bars
+ * apply: which side of the coin flip it fell on, and how far from the flip it
+ * landed. Both must be cleared, which is why "probability 0.55" never counts
+ * as a yes.
+ */
+export type DecisionBooleanGate = {
+    /** Minimum probability to read the answer as "yes". Default 0.5. */
+    minProbability?: number;
+    /** Minimum {@link decisionBooleanConfidence} to act at all. Default 0.4. */
+    minConfidence?: number;
+};

package/dist/types/decision.js

@@ -0,0 +1,21 @@
+/**
+ * Decision inference types — typed, calibrated judgements from a model that
+ * emits no text.
+ *
+ * `decide` is the third inference type, alongside `generate` and `stream`. A
+ * decision model takes one `state` plus a map of named typed questions and
+ * returns one typed answer per question, all evaluated in a single parallel
+ * pass. TypeSafe's Jev is the first such model; Vercel's AI SDK models the
+ * same class separately from `LanguageModelV4`, for the same reason.
+ *
+ * The vocabulary here is deliberately **provider-neutral**. TypeSafe calls a
+ * yes/no question a `noul` and answers it in a field of the same name; both
+ * the Vercel AI SDK and Pydantic AI independently renamed that to `boolean` /
+ * `probability` when exposing it. This file follows them, and the mapping to
+ * a vendor's wire format belongs in that vendor's provider.
+ *
+ * Names are domain-prefixed `Decision*` to stay globally unique across
+ * `src/lib/types/` (CLAUDE.md rule 9). Note `evaluate`/`Evaluation*` is a
+ * different, unrelated feature — scoring a generated response with RAGAS.
+ */
+export {};

package/dist/types/generate.d.ts

@@ -273,6 +273,13 @@ export type GenerateOptions = {
     region?: string;
     temperature?: number;
     maxTokens?: number;
+    /**
+     * Fraction of the model's context window at which history is compacted for
+     * this request, replacing the 0.8 default. Filled in per request by the
+     * classifier router when a decision provider is configured; always at or
+     * below the default, never above. See `TextGenerationOptions`.
+     */
+    compactionThreshold?: number;
     /** Top-p (nucleus) sampling parameter. Controls diversity of generated tokens. */
     topP?: number;
     /** Top-k sampling parameter. Limits the number of tokens considered. (Google/Gemini models only) */
@@ -1113,6 +1120,19 @@ export type FactoryEnhancedProvider = EnhancedProvider & {
  */
 export type TextGenerationOptions = {
     prompt?: string;
+    /**
+     * 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;
     /**
      * Alternative input format for multimodal SDK operations.
      *

package/dist/types/index.d.ts

@@ -98,3 +98,4 @@ export * from "./localUsage.js";
 export * from "./dispatch.js";
 export * from "./proxyRestart.js";
 export * from "./proxyBudget.js";
+export * from "./decision.js";

package/dist/types/index.js

@@ -113,3 +113,5 @@ export * from "./localUsage.js";
 export * from "./dispatch.js";
 export * from "./proxyRestart.js";
 export * from "./proxyBudget.js";
+// `decide` inference-type contracts (TypeSafe Jev is the first provider)
+export * from "./decision.js";