@juspay/neurolink 12.18.1 → 12.19.1

package/dist/factories/providerDescriptors.d.ts

@@ -14,3 +14,18 @@ export declare const PROVIDER_DESCRIPTORS_BY_NAME: ReadonlyMap<AIProviderName, P
  * ProviderFactory.normalizeProviderName().
  */
 export declare const PROVIDER_ALIAS_INDEX: ReadonlyMap<string, AIProviderName>;
+/**
+ * Providers that serve the `decide` inference type, derived from each
+ * descriptor's `inferenceKinds`. A provider that declares nothing is a text
+ * provider, so it is not here.
+ */
+export declare const DECISION_PROVIDERS: readonly ProviderDescriptor[];
+/**
+ * The decision provider to use when a caller names none: the first one whose
+ * primary credential env var is actually set.
+ *
+ * This is where "if somebody sets the key, we start using it" is implemented.
+ * Returns undefined when none is configured, which every internal consumer
+ * treats as "carry on exactly as before".
+ */
+export declare function resolveDefaultDecisionProvider(): string | undefined;

package/dist/factories/providerDescriptors.js

@@ -1,7 +1,8 @@
 import { AIProviderName } from "../constants/enums.js";
-import { GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
+import { GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, TypeSafeModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
 import { API_KEY_FORMATS } from "../utils/providerConfig.js";
 import { getCatalogJsonEntries, catalogCredentialsKey, catalogEnvVar, } from "../providers/catalog/loader.js";
+import { DEFAULT_INFERENCE_KINDS } from "../types/index.js";
 /**
  * Hand-maintained provider identity, credentials, defaults, and runtime
  * behavior classification for every provider EXCEPT the 8 JSON-catalog
@@ -462,6 +463,37 @@ const HAND_DESCRIPTORS = [
         healthCheck: "env-only",
         setupUrl: "https://www.recraft.ai/api",
     },
+    {
+        name: AIProviderName.TYPESAFE,
+        aliases: ["jev", "typesafe-ai"],
+        credentialsKey: "typesafe",
+        envVars: {
+            apiKey: "TYPESAFE_API_KEY",
+            // A Vercel AI Gateway key reaches the same model through a different
+            // transport, so it satisfies this provider on its own. Listing it here
+            // is what makes `resolveDefaultDecisionProvider()` — and therefore
+            // "if somebody sets the key, we start using it" — true for gateway
+            // users who never hold a TypeSafe key at all.
+            fallbacks: ["AI_GATEWAY_API_KEY"],
+            baseURL: "TYPESAFE_BASE_URL",
+            model: "TYPESAFE_MODEL",
+        },
+        defaultModel: TypeSafeModels.JEV_LATEST,
+        // Jev serves only the `decide` inference type. Declaring that here is
+        // what keeps it out of every generation code path, rather than each of
+        // those having to special-case the provider name.
+        inferenceKinds: ["decide"],
+        // It emits no text, so it cannot call tools and cannot answer a
+        // "live-generate" health probe.
+        toolSupport: "none",
+        localRuntime: false,
+        healthCheck: "env-only",
+        // Deliberately NO autoSelectPriority / autoSelectPreference /
+        // defaultHealthSweepPriority: all three feed generation fallback chains,
+        // and a text-less provider must never be reachable from them.
+        timeouts: { decideMs: 5000 },
+        setupUrl: "https://console.typesafe.ai/keys",
+    },
 ];
 /**
  * Builds ProviderDescriptor entries for 8 of the 9 JSON-catalog providers —
@@ -546,3 +578,27 @@ export const PROVIDER_ALIAS_INDEX = new Map(PROVIDER_DESCRIPTORS.flatMap((d) =>
     [d.name.toLowerCase(), d.name],
     ...d.aliases.map((alias) => [alias.toLowerCase(), d.name]),
 ]));
+/**
+ * Providers that serve the `decide` inference type, derived from each
+ * descriptor's `inferenceKinds`. A provider that declares nothing is a text
+ * provider, so it is not here.
+ */
+export const DECISION_PROVIDERS = PROVIDER_DESCRIPTORS.filter((d) => (d.inferenceKinds ?? DEFAULT_INFERENCE_KINDS).includes("decide"));
+/**
+ * The decision provider to use when a caller names none: the first one whose
+ * primary credential env var is actually set.
+ *
+ * This is where "if somebody sets the key, we start using it" is implemented.
+ * Returns undefined when none is configured, which every internal consumer
+ * treats as "carry on exactly as before".
+ */
+export function resolveDefaultDecisionProvider() {
+    for (const descriptor of DECISION_PROVIDERS) {
+        const primary = descriptor.envVars.apiKey;
+        const candidates = [primary, ...(descriptor.envVars.fallbacks ?? [])];
+        if (candidates.some((v) => v && (process.env[v] ?? "").trim() !== "")) {
+            return descriptor.name;
+        }
+    }
+    return undefined;
+}

package/dist/factories/providerRegistry.js

@@ -1,6 +1,6 @@
 import { ProviderFactory } from "./providerFactory.js";
 import { logger } from "../utils/logger.js";
-import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
+import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, ReplicateModels, } from "../constants/enums.js";
 import { PROVIDER_DESCRIPTORS_BY_NAME } from "./providerDescriptors.js";
 import { OPENAI_COMPAT_CATALOG } from "../providers/openaiCompatCatalog.js";
 import { providerChoicesFor } from "./mediaHandlerCatalog.js";
@@ -233,6 +233,14 @@ export class ProviderRegistry {
                 const { RecraftProvider } = await import("../providers/recraft.js");
                 return new RecraftProvider(modelName, sdk, undefined, recraftCreds);
             }, process.env.RECRAFT_MODEL || RecraftModels.RECRAFT_V3, ["recraft"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.RECRAFT));
+            // Register TypeSafe (Jev) — the `decide` inference type, not text.
+            // Its descriptor declares inferenceKinds: ["decide"], so nothing in the
+            // generation fallback chain can reach it.
+            ProviderFactory.registerProvider(AIProviderName.TYPESAFE, async (modelName, _providerName, sdk, _region, credentials) => {
+                const typesafeCreds = credentials;
+                const { TypeSafeProvider } = await import("../providers/typesafe.js");
+                return new TypeSafeProvider(modelName, sdk, undefined, typesafeCreds);
+            }, process.env.TYPESAFE_MODEL || TypeSafeModels.JEV_LATEST, ["jev", "typesafe-ai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.TYPESAFE));
             logger.debug("All AI providers registered successfully");
             // ===== MEDIA HANDLER REGISTRATION =====
             // Single registration path (Task 11): each ecosystem barrel (voice,

package/dist/index.d.ts

@@ -381,7 +381,63 @@ export { createMultiJudgeWorkflow, MULTI_JUDGE_3_WORKFLOW, MULTI_JUDGE_5_WORKFLO
  * });
  * ```
  */
-export { classifyProviderError, ModelPool, createDefaultRequestRouter, ClassifierRouter, classifyHeuristic, } from "./routing/index.js";
+export { classifyProviderError, ModelPool, createDefaultRequestRouter, ClassifierRouter, classifyHeuristic, classifyJev, } from "./routing/index.js";
+/**
+ * The `decide` inference type — typed, calibrated judgements from a model that
+ * generates no text, alongside `generate` and `stream`.
+ *
+ * Call it with `neurolink.decide({ state, questions })`, or `tryDecide()` for
+ * the fail-open variant every internal consumer uses. TypeSafe's Jev is the
+ * first provider; a provider declares the capability with `"decide"` in its
+ * descriptor's `inferenceKinds`.
+ *
+ * Latency on a decision model is flat in question count — 1 question ~393ms,
+ * 400 questions ~465ms — while concurrent requests queue. Always batch; never
+ * fan out. A `choice` answer carries the full distribution, so one question
+ * over N options also ranks all N.
+ *
+ * @example
+ * ```ts
+ * import { NeuroLink, readDecisionChoice } from '@juspay/neurolink';
+ *
+ * const result = await new NeuroLink().tryDecide({   // null if unconfigured
+ *   state: ticketText,
+ *   questions: {
+ *     team: {
+ *       type: 'choice',
+ *       instructions: 'Which team should handle this?',
+ *       criteria: { billing: 'Payments', technical: 'Bugs', sales: 'Pricing' },
+ *     },
+ *     urgent: { type: 'boolean', instructions: 'Is this urgent?' },
+ *   },
+ * });
+ * const team = result && readDecisionChoice(result.answers, 'team');
+ * if (team && team.confidence > 0.7) { route(team.choice); }
+ * ```
+ */
+export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, readDecisionBoolean, readDecisionChoice, readDecisionScore, servesInferenceKind, } from "./utils/decisionAnswers.js";
+export { DECISION_PROVIDERS, resolveDefaultDecisionProvider, } from "./factories/providerDescriptors.js";
+export { TYPESAFE_MAX_REQUEST_TOKENS, TYPESAFE_MAX_STATE_TOKENS, } from "./providers/typesafe.js";
+/**
+ * The decision consumers.
+ *
+ * Each takes an injected fail-open `decide` caller — a bound
+ * `NeuroLink.tryDecide` — and returns `null` when nothing should change, so a
+ * host that wires one into its own pipeline inherits the same degradation
+ * contract NeuroLink uses internally: no decision provider configured means
+ * the behaviour is exactly what it was before.
+ *
+ * They are exported because each is independently useful. A host routing its
+ * own tool set, compacting its own transcript, or planning its own retrieval
+ * should not have to reimplement the question wording, the calibration gates
+ * or the asymmetric thresholds that make these work.
+ */
+export { CLASSIFIER_CONTEXT_SCOPES, CLASSIFIER_DIFFICULTIES, contextScopeToThreshold, } from "./routing/classifierStrategies.js";
+export { buildModelCatalog, buildRegistryIndex, enrichCandidate, rankCatalogue, reachableTextProviders, renderCandidate, } from "./routing/modelCatalog.js";
+export { selectServersByDecision } from "./core/toolRoutingDecision.js";
+export { selectIrrelevantMessages, summaryPreservesContext, } from "./context/contextDecision.js";
+export { decideSearchPlan } from "./rag/retrieval/searchDecision.js";
+export { DEFAULT_COMPACTION_THRESHOLD, resolveHistoryBudget, } from "./context/budgetChecker.js";
 /**
  * Server Adapters for exposing NeuroLink as HTTP APIs
  *

package/dist/index.js

@@ -610,7 +610,66 @@ export { createMultiJudgeWorkflow, MULTI_JUDGE_3_WORKFLOW, MULTI_JUDGE_5_WORKFLO
  * });
  * ```
  */
-export { classifyProviderError, ModelPool, createDefaultRequestRouter, ClassifierRouter, classifyHeuristic, } from "./routing/index.js";
+export { classifyProviderError, ModelPool, createDefaultRequestRouter, ClassifierRouter, classifyHeuristic, classifyJev, } from "./routing/index.js";
+// ============================================================================
+// Decision inference type (`decide`)
+// ============================================================================
+/**
+ * The `decide` inference type — typed, calibrated judgements from a model that
+ * generates no text, alongside `generate` and `stream`.
+ *
+ * Call it with `neurolink.decide({ state, questions })`, or `tryDecide()` for
+ * the fail-open variant every internal consumer uses. TypeSafe's Jev is the
+ * first provider; a provider declares the capability with `"decide"` in its
+ * descriptor's `inferenceKinds`.
+ *
+ * Latency on a decision model is flat in question count — 1 question ~393ms,
+ * 400 questions ~465ms — while concurrent requests queue. Always batch; never
+ * fan out. A `choice` answer carries the full distribution, so one question
+ * over N options also ranks all N.
+ *
+ * @example
+ * ```ts
+ * import { NeuroLink, readDecisionChoice } from '@juspay/neurolink';
+ *
+ * const result = await new NeuroLink().tryDecide({   // null if unconfigured
+ *   state: ticketText,
+ *   questions: {
+ *     team: {
+ *       type: 'choice',
+ *       instructions: 'Which team should handle this?',
+ *       criteria: { billing: 'Payments', technical: 'Bugs', sales: 'Pricing' },
+ *     },
+ *     urgent: { type: 'boolean', instructions: 'Is this urgent?' },
+ *   },
+ * });
+ * const team = result && readDecisionChoice(result.answers, 'team');
+ * if (team && team.confidence > 0.7) { route(team.choice); }
+ * ```
+ */
+export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, readDecisionBoolean, readDecisionChoice, readDecisionScore, servesInferenceKind, } from "./utils/decisionAnswers.js";
+export { DECISION_PROVIDERS, resolveDefaultDecisionProvider, } from "./factories/providerDescriptors.js";
+export { TYPESAFE_MAX_REQUEST_TOKENS, TYPESAFE_MAX_STATE_TOKENS, } from "./providers/typesafe.js";
+/**
+ * The decision consumers.
+ *
+ * Each takes an injected fail-open `decide` caller — a bound
+ * `NeuroLink.tryDecide` — and returns `null` when nothing should change, so a
+ * host that wires one into its own pipeline inherits the same degradation
+ * contract NeuroLink uses internally: no decision provider configured means
+ * the behaviour is exactly what it was before.
+ *
+ * They are exported because each is independently useful. A host routing its
+ * own tool set, compacting its own transcript, or planning its own retrieval
+ * should not have to reimplement the question wording, the calibration gates
+ * or the asymmetric thresholds that make these work.
+ */
+export { CLASSIFIER_CONTEXT_SCOPES, CLASSIFIER_DIFFICULTIES, contextScopeToThreshold, } from "./routing/classifierStrategies.js";
+export { buildModelCatalog, buildRegistryIndex, enrichCandidate, rankCatalogue, reachableTextProviders, renderCandidate, } from "./routing/modelCatalog.js";
+export { selectServersByDecision } from "./core/toolRoutingDecision.js";
+export { selectIrrelevantMessages, summaryPreservesContext, } from "./context/contextDecision.js";
+export { decideSearchPlan } from "./rag/retrieval/searchDecision.js";
+export { DEFAULT_COMPACTION_THRESHOLD, resolveHistoryBudget, } from "./context/budgetChecker.js";
 // ============================================================================
 // SERVER ADAPTERS - HTTP API Framework Integration
 // ============================================================================

package/dist/models/manifestRegistry.js

@@ -19,6 +19,7 @@ import { lmStudioManifest } from "./manifests/lm-studio.js";
 import { llamacppManifest } from "./manifests/llamacpp.js";
 import { xaiManifest } from "./manifests/xai.js";
 import { groqManifest } from "./manifests/groq.js";
+import { typesafeManifest } from "./manifests/typesafe.js";
 import { cohereManifest } from "./manifests/cohere.js";
 import { togetherAiManifest } from "./manifests/together-ai.js";
 import { fireworksManifest } from "./manifests/fireworks.js";
@@ -107,6 +108,7 @@ export const MANIFEST_REGISTRY = {
     llamacpp: llamacppManifest,
     xai: xaiManifest,
     groq: groqManifest,
+    typesafe: typesafeManifest,
     cerebras: catalogManifest("cerebras"),
     sambanova: catalogManifest("sambanova"),
     cohere: cohereManifest,

package/dist/models/manifests/typesafe.d.ts

@@ -0,0 +1,16 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * TypeSafe (Jev) — the `decide` inference type, not text generation.
+ *
+ * `contextWindow` is genuinely meaningful here: it is the budget for the
+ * `state` being judged, measured by bisection at ~33,000 tokens for state
+ * plus the longest single question. (A separate, larger ~64,000 ceiling
+ * governs state plus ALL questions; the manifest has nowhere to express a
+ * second limit, and the tighter one is the safe number to publish.)
+ *
+ * `maxOutputTokens` is required by the manifest type but has no honest value
+ * for a model that emits no text — Jev returns a handful of numbers per
+ * question, so a small non-zero figure is the least misleading choice.
+ * `functionCalling` and `vision` are false: it has neither.
+ */
+export declare const typesafeManifest: ProviderModelManifest;

package/dist/models/manifests/typesafe.js

@@ -0,0 +1,42 @@
+/**
+ * TypeSafe (Jev) — the `decide` inference type, not text generation.
+ *
+ * `contextWindow` is genuinely meaningful here: it is the budget for the
+ * `state` being judged, measured by bisection at ~33,000 tokens for state
+ * plus the longest single question. (A separate, larger ~64,000 ceiling
+ * governs state plus ALL questions; the manifest has nowhere to express a
+ * second limit, and the tighter one is the safe number to publish.)
+ *
+ * `maxOutputTokens` is required by the manifest type but has no honest value
+ * for a model that emits no text — Jev returns a handful of numbers per
+ * question, so a small non-zero figure is the least misleading choice.
+ * `functionCalling` and `vision` are false: it has neither.
+ */
+export const typesafeManifest = {
+    defaultContextWindow: 33000,
+    models: {
+        _default: {
+            aliases: ["jev"],
+            contextWindow: 33000,
+            maxOutputTokens: 1024,
+            vision: false,
+            functionCalling: false,
+        },
+        "jev-latest": {
+            aliases: ["jev"],
+            displayName: "Jev (latest)",
+            contextWindow: 33000,
+            maxOutputTokens: 1024,
+            vision: false,
+            functionCalling: false,
+        },
+        "jev-preview": {
+            aliases: [],
+            displayName: "Jev (preview)",
+            contextWindow: 33000,
+            maxOutputTokens: 1024,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};

package/dist/neurolink.d.ts

@@ -5,7 +5,7 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
+import type { DecisionOptions, DecisionResult, AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
 import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
@@ -149,6 +149,7 @@ export declare class NeuroLink {
     private readonly modelPool;
     private readonly requestRouter;
     private readonly classifierRouter;
+    private readonly contextRelevanceOptions;
     /**
      * Merge instance-level credentials with per-call credentials.
      *
@@ -813,6 +814,14 @@ export declare class NeuroLink {
      * @param thinkingLevel — optional thinking level string from the call options.
      */
     private applyRequestRouter;
+    /**
+     * Dependencies handed to every `ContextCompactor`.
+     *
+     * `tryDecide` returns null whenever no decision provider is configured or
+     * the call fails, so passing this unconditionally is safe: the compactor
+     * runs its previous pipeline unchanged and pays nothing for the option.
+     */
+    private contextCompactorDeps;
     /**
      * Applies the host-configured `classifierRouter` to `options` in place.
      *
@@ -2318,6 +2327,53 @@ export declare class NeuroLink {
      * ```
      */
     createEvaluationPipeline(configOrPreset: import("./types/index.js").PipelineConfig | "safety" | "rag" | "quality" | "comprehensive" | "minimal" | "summarization" | "customerSupport" | "codeGeneration"): Promise<import("./evaluation/pipeline/evaluationPipeline.js").EvaluationPipeline>;
+    /**
+     * Run the `decide` inference type: evaluate a `state` against a batch of
+     * named, typed questions and get one typed answer each.
+     *
+     * This is NOT {@link NeuroLink.evaluate}, which scores an already-generated
+     * response with RAGAS scorers. `decide` calls a decision model — one that
+     * emits no text at all and returns calibrated, typed judgements your code
+     * can branch on.
+     *
+     * **Batch, never fan out.** On a decision model, latency is flat in
+     * question count (measured: 1 question 393ms, 400 questions 465ms) while
+     * concurrent requests queue. Put every question you might need into one
+     * call — speculative questions are nearly free, a second round trip is not.
+     *
+     * A `choice` answer carries the full probability distribution, so one
+     * question over N options also ranks all N.
+     *
+     * @example
+     * ```typescript
+     * const result = await neurolink.decide({
+     *   state: ticketText,
+     *   questions: {
+     *     team: {
+     *       type: "choice",
+     *       instructions: "Which team should handle this?",
+     *       criteria: { billing: "Payments", technical: "Bugs", sales: "Pricing" },
+     *     },
+     *     urgent: { type: "boolean", instructions: "Is this urgent?" },
+     *   },
+     * });
+     * const team = readDecisionChoice(result.answers, "team");
+     * if (team && team.confidence > 0.7) { assign(team.choice); }
+     * ```
+     *
+     * @throws when no decision provider is configured, or the call fails
+     */
+    decide(options: DecisionOptions): Promise<DecisionResult>;
+    /**
+     * Fail-open {@link NeuroLink.decide}: returns null on any failure instead
+     * of throwing.
+     *
+     * This is the contract every internal consumer relies on. A decision model
+     * that is unconfigured, slow, rate-limited or down must never change
+     * NeuroLink's observable behaviour — the caller falls back to whatever it
+     * did before the decision was available.
+     */
+    tryDecide(options: DecisionOptions): Promise<DecisionResult | null>;
     /**
      * Evaluate an AI response using the specified pipeline or scorers.
      * This is a convenience method that creates a pipeline and executes it in one call.