@juspay/neurolink 10.3.0 → 10.4.0

package/dist/cli/loop/optionsSchema.js

@@ -118,5 +118,9 @@ export const textGenerationOptionsSchema = {
         type: "boolean",
         description: "Disable tool result caching for this request (overrides global mcp.cache.enabled).",
     },
+    disableToolCallRepair: {
+        type: "boolean",
+        description: "Disable the schema-driven tool call repair mechanism (near-miss tool names, mis-typed arguments). Repair is enabled by default.",
+    },
 };
 //# sourceMappingURL=optionsSchema.js.map

package/dist/constants/contextWindows.d.ts

@@ -30,6 +30,30 @@ export declare const MODEL_CONTEXT_WINDOWS: Record<string, Record<string, number
 export declare function registerRuntimeContextWindow(provider: string, model: string, contextWindow: number): void;
 /** Test hook: clear runtime-discovered windows (state is module-global). */
 export declare function clearRuntimeContextWindows(): void;
+/**
+ * Runtime-discovered window for an exact provider/model pair, or undefined.
+ *
+ * Unlike {@link getContextWindowSize} this NEVER falls back to static table
+ * values. Callers use it to distinguish "the serving infrastructure told us
+ * the real window" (safe to hard-enforce: clamp max_tokens, fail fast) from
+ * "static guess" (advisory only — hard-enforcing a guessed window would
+ * falsely reject requests that the real deployment accepts).
+ */
+export declare function getRuntimeContextWindow(provider: string, model?: string): number | undefined;
+/**
+ * Register a runtime-discovered output-token ceiling for a provider/model
+ * pair. Later registrations overwrite earlier ones (rediscovery refreshes
+ * values). Non-positive/non-finite ceilings are ignored so a malformed
+ * discovery source can never shrink an output budget to zero.
+ */
+export declare function registerRuntimeOutputCeiling(provider: string, model: string, maxOutputTokens: number): void;
+/**
+ * Runtime-discovered output ceiling for an exact provider/model pair, or
+ * undefined when the serving infrastructure has not advertised one.
+ */
+export declare function getRuntimeOutputCeiling(provider: string, model?: string): number | undefined;
+/** Test hook: clear runtime-discovered output ceilings (state is module-global). */
+export declare function clearRuntimeOutputCeilings(): void;
 /**
  * Resolve context window size for a provider/model combination.
  *

package/dist/constants/contextWindows.js

@@ -420,6 +420,56 @@ export function registerRuntimeContextWindow(provider, model, contextWindow) {
 export function clearRuntimeContextWindows() {
     RUNTIME_CONTEXT_WINDOWS.clear();
 }
+/**
+ * Runtime-discovered window for an exact provider/model pair, or undefined.
+ *
+ * Unlike {@link getContextWindowSize} this NEVER falls back to static table
+ * values. Callers use it to distinguish "the serving infrastructure told us
+ * the real window" (safe to hard-enforce: clamp max_tokens, fail fast) from
+ * "static guess" (advisory only — hard-enforcing a guessed window would
+ * falsely reject requests that the real deployment accepts).
+ */
+export function getRuntimeContextWindow(provider, model) {
+    if (!model) {
+        return undefined;
+    }
+    return RUNTIME_CONTEXT_WINDOWS.get(`${provider}:${model}`);
+}
+/**
+ * Runtime-discovered output-token ceilings, keyed `${provider}:${model}` —
+ * the `max_output_tokens` the serving infrastructure advertises for a model
+ * (e.g. LiteLLM `/model/info`). Same async-populate/sync-read contract as
+ * {@link registerRuntimeContextWindow}. Consumed by `getSafeMaxTokens` so
+ * requested maxTokens is clamped to the deployed model's real cap instead of
+ * a static per-provider table value.
+ */
+const RUNTIME_OUTPUT_CEILINGS = new Map();
+/**
+ * Register a runtime-discovered output-token ceiling for a provider/model
+ * pair. Later registrations overwrite earlier ones (rediscovery refreshes
+ * values). Non-positive/non-finite ceilings are ignored so a malformed
+ * discovery source can never shrink an output budget to zero.
+ */
+export function registerRuntimeOutputCeiling(provider, model, maxOutputTokens) {
+    if (!Number.isFinite(maxOutputTokens) || maxOutputTokens <= 0) {
+        return;
+    }
+    RUNTIME_OUTPUT_CEILINGS.set(`${provider}:${model}`, maxOutputTokens);
+}
+/**
+ * Runtime-discovered output ceiling for an exact provider/model pair, or
+ * undefined when the serving infrastructure has not advertised one.
+ */
+export function getRuntimeOutputCeiling(provider, model) {
+    if (!model) {
+        return undefined;
+    }
+    return RUNTIME_OUTPUT_CEILINGS.get(`${provider}:${model}`);
+}
+/** Test hook: clear runtime-discovered output ceilings (state is module-global). */
+export function clearRuntimeOutputCeilings() {
+    RUNTIME_OUTPUT_CEILINGS.clear();
+}
 /**
  * Resolve context window size for a provider/model combination.
  *

package/dist/context/errorDetection.d.ts

@@ -23,6 +23,12 @@ export declare function getContextOverflowProvider(error: unknown): string | nul
 export declare function parseProviderOverflowDetails(error: unknown): {
     actualTokens: number;
     budgetTokens: number;
+    /**
+     * Output tokens the rejected request asked for, when the message states
+     * them separately (vllm/LiteLLM phrasing). Lets recovery re-fit
+     * max_tokens instead of shrinking the input.
+     */
+    requestedOutputTokens?: number;
 } | null;
 /**
  * Extract error message from various error formats.

package/dist/context/errorDetection.js

@@ -113,6 +113,24 @@ export function parseProviderOverflowDetails(error) {
             budgetTokens: parseInt(openaiMax[1].replace(/,/g, ""), 10),
         };
     }
+    // vllm / LiteLLM-proxied backends: "This model's maximum context length is
+    // N tokens. However, you requested X output tokens and your prompt contains
+    // at least Y input tokens..." — input and requested-output are stated
+    // separately (no "resulted in"), so recovery can re-fit max_tokens to
+    // N − Y instead of shrinking the input.
+    const vllmInput = message.match(/prompt\s+contains\s+at\s+least\s+(\d[\d,]{0,19})\s+input\s+tokens/i);
+    if (vllmInput && openaiMax) {
+        const requestedOutput = message.match(/requested\s+(\d[\d,]{0,19})\s+output\s+tokens/i);
+        return {
+            actualTokens: parseInt(vllmInput[1].replace(/,/g, ""), 10),
+            budgetTokens: parseInt(openaiMax[1].replace(/,/g, ""), 10),
+            ...(requestedOutput
+                ? {
+                    requestedOutputTokens: parseInt(requestedOutput[1].replace(/,/g, ""), 10),
+                }
+                : {}),
+        };
+    }
     // Anthropic pattern: "X tokens > Y token limit" or "X tokens, limit Y"
     // Use single character-class number groups to prevent ReDoS (CodeQL: js/polynomial-redos)
     const anthropicMatch = message.match(/(\d[\d,]{0,19})\s*tokens?\s*[>:]\s*(\d[\d,]{0,19})/i);

package/dist/context/stepBudgetGuard.d.ts

@@ -41,7 +41,21 @@ export declare function estimateStepMessagesTokens(messages: readonly ModelMessa
 export declare function estimateFixedOverheadTokens(system: unknown, tools: Record<string, unknown> | undefined, provider?: string): number;
 /**
  * Create a per-step budget guard. Returns a function that, given the step's
- * messages, returns a compacted replacement array when the projected request
- * exceeds the threshold — or `undefined` when no change is needed.
+ * messages (and optionally the REAL input-token count the provider reported
+ * for the previous step), returns a compacted replacement array when the
+ * projected request exceeds the threshold — or `undefined` when no change is
+ * needed.
+ *
+ * Two dynamic behaviours:
+ *  - the available-input budget is re-resolved on EVERY invocation, so
+ *    runtime window discovery (`/model/info`, overflow self-healing) that
+ *    lands mid-loop takes effect immediately instead of the guard staying
+ *    frozen on the value captured at loop start;
+ *  - usage feedback calibrates the estimator: the ratio between the real
+ *    prompt tokens of the previous step and this guard's own estimate for
+ *    what that step sent scales later estimates (only UP — underestimates
+ *    overflow, overestimates merely compact earlier), eliminating the
+ *    char-based estimator's drift on dense code/diff content without
+ *    shipping a tokenizer.
  */
-export declare function createStepBudgetGuard(config: StepBudgetGuardConfig): (messages: readonly ModelMessage[]) => ModelMessage[] | undefined;
+export declare function createStepBudgetGuard(config: StepBudgetGuardConfig): (messages: readonly ModelMessage[], observedInputTokensLastStep?: number) => ModelMessage[] | undefined;

package/dist/context/stepBudgetGuard.js

@@ -37,6 +37,13 @@ import { generateToolOutputPreview } from "./toolOutputLimits.js";
 import { logger } from "../utils/logger.js";
 /** Estimated tokens for a tool definition that fails to serialize. */
 const TOKENS_PER_TOOL_DEFINITION = 200;
+/**
+ * Upper bound on the usage-feedback calibration ratio. Real tokenizers count
+ * dense code/diff content at up to ~1.3× the char-based estimate; anything
+ * far beyond that indicates inconsistent provider usage reporting, and an
+ * unbounded ratio would compact the loop into uselessness.
+ */
+const MAX_CALIBRATION_RATIO = 3;
 /** Messages at the end of the conversation the guard never modifies. */
 const PROTECTED_TAIL_MESSAGES = 4;
 /** Stage-1 preview budget for an old tool output (bytes). */
@@ -230,19 +237,45 @@ function dropOldestToolExchanges(messages, budgetTokens, fixedOverheadTokens, pr
 }
 /**
  * Create a per-step budget guard. Returns a function that, given the step's
- * messages, returns a compacted replacement array when the projected request
- * exceeds the threshold — or `undefined` when no change is needed.
+ * messages (and optionally the REAL input-token count the provider reported
+ * for the previous step), returns a compacted replacement array when the
+ * projected request exceeds the threshold — or `undefined` when no change is
+ * needed.
+ *
+ * Two dynamic behaviours:
+ *  - the available-input budget is re-resolved on EVERY invocation, so
+ *    runtime window discovery (`/model/info`, overflow self-healing) that
+ *    lands mid-loop takes effect immediately instead of the guard staying
+ *    frozen on the value captured at loop start;
+ *  - usage feedback calibrates the estimator: the ratio between the real
+ *    prompt tokens of the previous step and this guard's own estimate for
+ *    what that step sent scales later estimates (only UP — underestimates
+ *    overflow, overestimates merely compact earlier), eliminating the
+ *    char-based estimator's drift on dense code/diff content without
+ *    shipping a tokenizer.
  */
 export function createStepBudgetGuard(config) {
     const { provider, model, maxTokens, fixedOverheadTokens = 0, getFixedOverheadTokens, thresholdRatio = DEFAULT_CONTEXT_GUARD_RATIO, } = config;
-    const availableInput = getAvailableInputTokens(provider, model, maxTokens);
-    const thresholdTokens = Math.floor(availableInput * thresholdRatio);
-    return function guardStepMessages(messages) {
+    // Calibration state: raw estimate for the messages the PREVIOUS guard
+    // invocation let through (what was actually sent), and the current ratio.
+    let lastRawEstimate = 0;
+    let calibration = 1;
+    return function guardStepMessages(messages, observedInputTokensLastStep) {
+        const availableInput = getAvailableInputTokens(provider, model, maxTokens);
+        const thresholdTokens = Math.floor(availableInput * thresholdRatio);
         // Resolve overhead per invocation: the tool set can GROW mid-loop
         // (search_tools hydration adds discovered tools between steps), so a
         // once-captured value would undercount later steps.
         const overheadTokens = getFixedOverheadTokens?.() ?? fixedOverheadTokens;
-        const estimate = overheadTokens + estimateStepMessagesTokens(messages, provider);
+        const rawEstimate = overheadTokens + estimateStepMessagesTokens(messages, provider);
+        if (observedInputTokensLastStep !== undefined &&
+            observedInputTokensLastStep > 0 &&
+            lastRawEstimate > 0) {
+            calibration = Math.min(MAX_CALIBRATION_RATIO, Math.max(1, observedInputTokensLastStep / lastRawEstimate));
+        }
+        // Apply calibration to the THRESHOLD instead of every estimate so the
+        // compaction stages keep operating on raw numbers.
+        const effectiveThreshold = Math.floor(thresholdTokens / calibration);
         // Logger Guard: per-step diagnostics for debugging why a long run does
         // (or does not) trigger compaction — gated so nothing is serialized when
         // debug logging is off.
@@ -251,12 +284,15 @@ export function createStepBudgetGuard(config) {
                 provider,
                 model,
                 messageCount: messages.length,
-                estimatedTokens: estimate,
-                thresholdTokens,
-                willCompact: estimate > thresholdTokens,
+                estimatedTokens: rawEstimate,
+                thresholdTokens: effectiveThreshold,
+                calibration,
+                observedInputTokensLastStep,
+                willCompact: rawEstimate > effectiveThreshold,
             });
         }
-        if (estimate <= thresholdTokens) {
+        if (rawEstimate <= effectiveThreshold) {
+            lastRawEstimate = rawEstimate;
             return undefined;
         }
         // Stage 1: shrink old tool outputs to previews.
@@ -265,25 +301,28 @@ export function createStepBudgetGuard(config) {
         let newEstimate = overheadTokens + estimateStepMessagesTokens(compacted, provider);
         // Stage 2: drop oldest complete tool exchanges if still over.
         let droppedExchanges = 0;
-        if (newEstimate > thresholdTokens) {
-            const stage2 = dropOldestToolExchanges(compacted, thresholdTokens, overheadTokens, provider);
+        if (newEstimate > effectiveThreshold) {
+            const stage2 = dropOldestToolExchanges(compacted, effectiveThreshold, overheadTokens, provider);
             compacted = stage2.messages;
             droppedExchanges = stage2.droppedExchanges;
             newEstimate =
                 overheadTokens + estimateStepMessagesTokens(compacted, provider);
         }
         if (stage1.truncated === 0 && droppedExchanges === 0) {
+            lastRawEstimate = rawEstimate;
             return undefined; // nothing actionable (already all-protected)
         }
         logger.info("[StepBudgetGuard] Compacted agent-loop step messages", {
             provider,
             model,
-            estimatedTokens: estimate,
-            thresholdTokens,
+            estimatedTokens: rawEstimate,
+            thresholdTokens: effectiveThreshold,
+            calibration,
             afterTokens: newEstimate,
             toolOutputsTruncated: stage1.truncated,
             exchangesDropped: droppedExchanges,
         });
+        lastRawEstimate = newEstimate;
         return compacted;
     };
 }

package/dist/core/baseProvider.d.ts

@@ -185,6 +185,18 @@ export declare abstract class BaseProvider implements AIProvider {
      * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
      * for consistency and better performance
      */
+    /**
+     * Ensure runtime-discovered model limits (context window, output-token
+     * ceiling) are registered before any budget math runs. Generation
+     * pipelines await this BEFORE `checkContextBudget`, and generate()/stream()
+     * await it before options normalization so `getSafeMaxTokens` sees the
+     * discovered output ceiling.
+     *
+     * Default no-op. Providers with a runtime discovery source override it
+     * (e.g. LiteLLM's `/model/info`). Implementations must NEVER reject —
+     * discovery failure degrades to the static defaults.
+     */
+    ensureModelLimits(): Promise<void>;
     generate(optionsOrPrompt: TextGenerationOptions | string, _analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     /**
      * Alias for generate method - implements AIProvider interface

package/dist/core/baseProvider.js

@@ -118,6 +118,9 @@ export class BaseProvider {
      * When tools are involved, falls back to generate() with synthetic streaming
      */
     async stream(optionsOrPrompt, analysisSchema) {
+        // Runtime model limits must land before normalizeStreamOptions resolves
+        // maxTokens (getSafeMaxTokens consults the discovered output ceiling).
+        await this.ensureModelLimits();
         let options = this.normalizeStreamOptions(optionsOrPrompt);
         logger.info(`Starting stream`, {
             provider: this.providerName,
@@ -855,7 +858,22 @@ export class BaseProvider {
      * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
      * for consistency and better performance
      */
+    /**
+     * Ensure runtime-discovered model limits (context window, output-token
+     * ceiling) are registered before any budget math runs. Generation
+     * pipelines await this BEFORE `checkContextBudget`, and generate()/stream()
+     * await it before options normalization so `getSafeMaxTokens` sees the
+     * discovered output ceiling.
+     *
+     * Default no-op. Providers with a runtime discovery source override it
+     * (e.g. LiteLLM's `/model/info`). Implementations must NEVER reject —
+     * discovery failure degrades to the static defaults.
+     */
+    async ensureModelLimits() { }
     async generate(optionsOrPrompt, _analysisSchema) {
+        // Runtime model limits must land before normalizeTextOptions resolves
+        // maxTokens (getSafeMaxTokens consults the discovered output ceiling).
+        await this.ensureModelLimits();
         const options = this.normalizeTextOptions(optionsOrPrompt);
         this.validateOptions(options);
         const startTime = Date.now();