@juspay/neurolink 12.16.0 → 12.17.0

package/dist/providers/openaiChatCompletionsBase.js

@@ -20,6 +20,8 @@
 import { trace } from "@opentelemetry/api";
 import { getAvailableInputTokens, getRuntimeContextWindow, getRuntimeOutputCeiling, registerRuntimeContextWindow, } from "../constants/contextWindows.js";
 import { guardOpenAICompatConversation } from "../context/openaiCompatLoopGuard.js";
+import { estimateTokens, serializeForEstimate, } from "../utils/tokenEstimation.js";
+import { createNativeGenerateGuard } from "../context/nativeGenerateGuard.js";
 import { isContextOverflowError, parseProviderOverflowDetails, } from "../context/errorDetection.js";
 import { ContextBudgetExceededError } from "../context/errors.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -899,6 +901,19 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         // legal again on a vendor that refuses the two together.
         withTools = true) => runNativeGenerateLoop({
             doGenerate,
+            ...createNativeGenerateGuard({
+                provider: this.providerName,
+                availableInputTokens: getAvailableInputTokens(this.providerName, modelId, options.maxTokens ?? undefined),
+                // Runs on every step of the generate loop, so a cyclic or
+                // oversized tool schema must not throw the turn away. Shares the
+                // estimator's own serializer: its fallback over-reports, which
+                // makes the guard fire rather than silently size the overhead at
+                // nothing.
+                getFixedOverheadTokens: () => estimateTokens(serializeForEstimate({
+                    tools: v3Tools,
+                    responseFormat: format,
+                }), this.providerName),
+            }),
             conversation: conv,
             ...(withTools && v3Tools ? { tools: v3Tools } : {}),
             toolsRecord,

package/dist/types/config.d.ts

@@ -415,6 +415,16 @@ export type ToolConfig = {
     enableMCPTools?: boolean;
     /** Whether the bash command execution tool should be enabled (opt-in, defaults to false) */
     enableBashTool?: boolean;
+    /**
+     * Byte ceiling for the safety-net truncation `ToolsManager` applies to
+     * every direct/custom/external-MCP tool result before it reaches the AI
+     * SDK accumulator (BZ-666). Independent of `mcp.outputLimits`, which only
+     * governs external MCP results earlier in the pipeline via its own
+     * externalize-to-artifact-store strategy. Default: 51200 (50 KB) —
+     * unchanged from the previous hard-coded ceiling, so existing consumers
+     * see no behavior change unless they set this explicitly.
+     */
+    outputTruncationMaxBytes?: number;
 };
 /**
  * Backup metadata information

package/dist/types/context.d.ts

@@ -373,6 +373,15 @@ export type ToolOutputPreviewOptions = {
     headRatio?: number;
     /** Fraction of preview budget allocated to the tail (default: 0.75) */
     tailRatio?: number;
+    /**
+     * Override the omission notice spliced between head and tail. A string is
+     * used verbatim; a function receives the omitted byte count and returns
+     * the notice text. When omitted, the built-in default is used, which
+     * names the `retrieve_context` tool — pass this when that tool is not
+     * registered on the calling instance so the model isn't pointed at a tool
+     * that doesn't exist.
+     */
+    notice?: string | ((omittedBytes: number) => string);
 };
 /** Result of tool output preview generation. */
 export type ToolOutputPreviewResult = {
@@ -562,4 +571,10 @@ export type FileSummarizationServiceOptions = {
     provider?: string;
     model?: string;
 };
+/** Per-turn configuration for reclaiming a native V3 conversation. */
+export type NativeGenerateGuardConfig = {
+    provider: string;
+    availableInputTokens: number;
+    getFixedOverheadTokens: () => number;
+};
 export {};

package/dist/types/generate.d.ts

@@ -1604,6 +1604,15 @@ export type GenerateOptionsNormalized = GenerateOptions & {
  * `doGenerate`; the provider supplies the wire details.
  */
 export type NativeGenerateLoopArgs = {
+    /** Observed usage for calibrating the next step against the last request. */
+    observeUsage?: (usage: unknown) => void;
+    /**
+     * Per-step context reclaim, called before every model call with the
+     * conversation as it now stands. Return a replacement to have the loop adopt
+     * it, or undefined to leave it untouched. The provider owns this because the
+     * reclaim has to understand its wire shape.
+     */
+    guardConversation?: (conversation: Array<Record<string, unknown>>) => Array<Record<string, unknown>> | undefined;
     doGenerate: (options: Record<string, unknown>) => Promise<Record<string, unknown>>;
     /** Conversation in the message-builder shape each doGenerate converts itself. */
     conversation: Array<Record<string, unknown>>;

package/dist/utils/tokenEstimation.d.ts

@@ -47,6 +47,19 @@ export declare function getProviderMultiplier(provider?: string): number;
  * @returns Estimated token count
  */
 export declare function estimateTokens(text: string, provider?: string, isCode?: boolean): number;
+/**
+ * Serialize an arbitrary value for estimation. Never throws: `JSON.stringify`
+ * raises RangeError once a value exceeds V8's max string length, and a tool
+ * argument blob is exactly the shape that gets there. A payload that large is
+ * charged at the fallback size rather than aborting the estimate (and with it
+ * the whole turn).
+ */
+/**
+ * Serialize a value for token estimation. The fallback is deliberately huge:
+ * an estimator that cannot measure a value must over-report, so a budget guard
+ * fires rather than waving through content it failed to size.
+ */
+export declare function serializeForEstimate(value: unknown): string;
 /**
  * Estimate token count for a single ChatMessage.
  * Includes message framing overhead.

package/dist/utils/tokenEstimation.js

@@ -93,7 +93,12 @@ export function estimateTokens(text, provider, isCode) {
  * charged at the fallback size rather than aborting the estimate (and with it
  * the whole turn).
  */
-function serializeForEstimate(value) {
+/**
+ * Serialize a value for token estimation. The fallback is deliberately huge:
+ * an estimator that cannot measure a value must over-report, so a budget guard
+ * fires rather than waving through content it failed to size.
+ */
+export function serializeForEstimate(value) {
     if (typeof value === "string") {
         return value;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.16.0",
+  "version": "12.17.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -166,7 +166,9 @@
     "test:agents-live": "tsx test/continuous-test-agents-live.ts",
     "test:tool-routing-cli": "pnpm exec tsx test/continuous-test-suite-tool-routing-cli.ts",
     "test:tool-dedup": "pnpm exec tsx test/continuous-test-suite-tool-dedup.ts",
+    "test:tools-manager-truncation": "pnpm exec tsx test/continuous-test-suite-tools-manager-truncation.ts",
     "test:model-not-found-retryable": "pnpm exec tsx test/continuous-test-suite-model-not-found-retryable.ts",
+    "test:reasoning-parity-live": "pnpm exec tsx test/continuous-test-suite-reasoning-parity-live.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
     "// CI tier — fast, no live AI calls, safe for every commit (test:unit; also see the separate provider-safety-net CI job, which runs build + test:providers-mocked + test:provider-structure + test:error-classifier-contract on every PR)": "",
     "test:tool-routing": "pnpm exec tsx test/continuous-test-suite-tool-routing.ts",