@juspay/neurolink 12.16.0 → 12.17.1

package/dist/providers/anthropic/client.js

@@ -34,7 +34,7 @@ import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
 import { raceWithAbort } from "../../utils/async/index.js";
-import { resolveToolChoice } from "../../utils/toolChoice.js";
+import { normalizeResolvedToolChoice, resolveToolChoice, } from "../../utils/toolChoice.js";
 import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { NoOutputGeneratedError } from "../../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../../utils/noOutputSentinel.js";
@@ -1074,10 +1074,20 @@ export class AnthropicProvider extends BaseProvider {
                 if (tools && tools.length === 0) {
                     tools = undefined;
                 }
-                let toolChoice = options.toolChoice
-                    ? toolChoiceToAnthropic(options.toolChoice.type === "tool"
-                        ? { type: "tool", toolName: options.toolChoice.toolName }
-                        : options.toolChoice.type)
+                // The value here has already been through `resolveToolChoice`
+                // upstream in `executeNativeGenerate`, so this layer translates
+                // rather than re-resolves — re-resolving would apply the auto/none
+                // defaulting twice, and `toolsRecord`/`shouldUseTools` are not in
+                // scope inside `getAISDKModel` in any case.
+                //
+                // Only the SHAPE varies, and reading `.type` off it was the bug:
+                // a bare `"required"` has no `.type`, so the translator received
+                // `undefined` and the field was dropped from the request entirely.
+                // Normalisation now lives in the shared util rather than being
+                // re-derived here, so this site cannot drift from its siblings again.
+                const normalisedToolChoice = normalizeResolvedToolChoice(options.toolChoice);
+                let toolChoice = normalisedToolChoice
+                    ? toolChoiceToAnthropic(normalisedToolChoice)
                     : undefined;
                 // JSON/structured output: Anthropic has no response_format — emulate
                 // with a forced synthetic tool whose input IS the JSON payload (the

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/dist/utils/toolChoice.d.ts

@@ -2,3 +2,22 @@ import type { Tool, ToolChoice } from "../types/index.js";
 export declare function resolveToolChoice(options: {
     toolChoice?: ToolChoice<Record<string, Tool>>;
 }, tools: Record<string, Tool> | undefined, shouldUseTools: boolean): ToolChoice<Record<string, Tool>> | "none";
+/**
+ * Normalise an already-resolved tool choice into the shape
+ * `toolChoiceToAnthropic` (and its peers) accept.
+ *
+ * A provider's model handle sees a value that has *already* been through
+ * `resolveToolChoice` upstream, so it must translate rather than re-resolve —
+ * re-resolving there would apply the `auto`/`none` defaulting twice, and the
+ * `tools`/`shouldUseTools` inputs it needs are not in scope at that layer
+ * anyway.
+ *
+ * What does vary is the shape. The value arrives either as a bare string
+ * (`"auto"` / `"none"` / `"required"`), as `{ type: "tool", toolName }`, or —
+ * on the native loop's tool-free re-ask — as an injected `{ type: "none" }`
+ * object. Reading `.type` off the string forms yields `undefined`, which is
+ * how string choices were silently dropped from the Anthropic generate
+ * request. This exists so that normalisation lives in one place instead of
+ * being re-derived at each call site.
+ */
+export declare function normalizeResolvedToolChoice(value: unknown): ToolChoice<Record<string, Tool>> | undefined;

package/dist/utils/toolChoice.js

@@ -4,3 +4,42 @@ export function resolveToolChoice(options, tools, shouldUseTools) {
     }
     return options.toolChoice ?? "auto";
 }
+/**
+ * Normalise an already-resolved tool choice into the shape
+ * `toolChoiceToAnthropic` (and its peers) accept.
+ *
+ * A provider's model handle sees a value that has *already* been through
+ * `resolveToolChoice` upstream, so it must translate rather than re-resolve —
+ * re-resolving there would apply the `auto`/`none` defaulting twice, and the
+ * `tools`/`shouldUseTools` inputs it needs are not in scope at that layer
+ * anyway.
+ *
+ * What does vary is the shape. The value arrives either as a bare string
+ * (`"auto"` / `"none"` / `"required"`), as `{ type: "tool", toolName }`, or —
+ * on the native loop's tool-free re-ask — as an injected `{ type: "none" }`
+ * object. Reading `.type` off the string forms yields `undefined`, which is
+ * how string choices were silently dropped from the Anthropic generate
+ * request. This exists so that normalisation lives in one place instead of
+ * being re-derived at each call site.
+ */
+export function normalizeResolvedToolChoice(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        const candidate = value;
+        if (candidate.type === "tool") {
+            // A tool choice that names no tool cannot be honoured. Fall through to
+            // the provider default rather than emitting the bare string "tool",
+            // which is not one of the valid auto/none/required forms and would be
+            // rejected downstream.
+            return candidate.toolName
+                ? { type: "tool", toolName: candidate.toolName }
+                : undefined;
+        }
+        if (candidate.type) {
+            return candidate.type;
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.16.0",
+  "version": "12.17.1",
   "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": {
@@ -117,6 +117,7 @@
     "test:thinking-config": "pnpm exec tsx test/continuous-test-suite-sdk-thinking-config.ts",
     "test:gemini-thinking-level": "pnpm exec tsx test/continuous-test-suite-gemini-thinking-level.ts",
     "test:gemini-thinking-level-ai-studio": "pnpm exec tsx test/continuous-test-suite-gemini-thinking-level-ai-studio.ts",
+    "test:anthropic-toolchoice": "pnpm exec tsx test/continuous-test-suite-anthropic-toolchoice.ts",
     "test:mcp:spans": "pnpm exec tsx test/continuous-test-suite-mcp-spans.ts",
     "test:mcp:infra": "pnpm exec tsx test/continuous-test-suite-mcp-infra.ts",
     "test:vendor-recovery": "pnpm exec tsx test/continuous-test-suite-native-vendor-recovery.ts",
@@ -166,7 +167,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",