@juspay/neurolink 12.12.7 → 12.12.9

package/dist/core/toolExecutionRecorder.d.ts

@@ -9,7 +9,7 @@
  * params, timing, and error status. Memory is bounded: serialized results are
  * capped at `maxResultChars` and the record list at `maxRecords`.
  */
-import type { Tool, ToolExecutionCaptureOptions, ToolExecutionRecord } from "../types/index.js";
+import type { Tool, ToolExecutionCaptureOptions, ToolExecutionRecord, StandardRecord, ToolExecutionSummaryInternal } from "../types/index.js";
 /** Default cap on serialized result characters kept per record (~8KB). */
 export declare const DEFAULT_TOOL_RESULT_CAPTURE_CHARS = 8192;
 /** Default cap on records kept per turn. */
@@ -73,4 +73,19 @@ export declare function toToolExecutionRecords(legacyExecutions: unknown[] | und
  * carried a recorder that saw executions, else a conversion of the loop's
  * legacy accumulator entries.
  */
+/**
+ * The public `toolCalls` view of a native turn's execution summaries.
+ *
+ * The native generate loops record every executed call in
+ * `ToolExecutionSummaryInternal[]` and surface it as `toolExecutions`, but
+ * never mapped it onto `EnhancedGenerateResult.toolCalls` — the field the type
+ * has always declared and the ai-package formatter used to fill. A caller
+ * reading `result.toolCalls` after a tool ran saw nothing. This is the one
+ * place that mapping lives, so the three native paths cannot drift apart.
+ */
+export declare function toolCallsFromSummaries(summaries: ReadonlyArray<ToolExecutionSummaryInternal>): Array<{
+    toolCallId: string;
+    toolName: string;
+    args: StandardRecord;
+}>;
 export declare function resolveToolExecutionRecords(options: unknown, legacyExecutions?: unknown[]): ToolExecutionRecord[];

package/dist/core/toolExecutionRecorder.js

@@ -247,6 +247,27 @@ export function toToolExecutionRecords(legacyExecutions, capture) {
  * carried a recorder that saw executions, else a conversion of the loop's
  * legacy accumulator entries.
  */
+/**
+ * The public `toolCalls` view of a native turn's execution summaries.
+ *
+ * The native generate loops record every executed call in
+ * `ToolExecutionSummaryInternal[]` and surface it as `toolExecutions`, but
+ * never mapped it onto `EnhancedGenerateResult.toolCalls` — the field the type
+ * has always declared and the ai-package formatter used to fill. A caller
+ * reading `result.toolCalls` after a tool ran saw nothing. This is the one
+ * place that mapping lives, so the three native paths cannot drift apart.
+ */
+export function toolCallsFromSummaries(summaries) {
+    return summaries.map((summary) => ({
+        toolCallId: summary.toolCallId,
+        toolName: summary.toolName,
+        args: summary.input !== null &&
+            typeof summary.input === "object" &&
+            !Array.isArray(summary.input)
+            ? summary.input
+            : {},
+    }));
+}
 export function resolveToolExecutionRecords(options, legacyExecutions) {
     const recorder = ToolExecutionRecorder.from(options);
     if (recorder?.hasRecords()) {

package/dist/middleware/builtin/guardrails.js

@@ -1,6 +1,45 @@
 import { createBlockedResponse, createBlockedStream, applyContentFiltering, handlePrecallGuardrails, } from "../utils/guardrailsUtils.js";
 import { logger } from "../../utils/logger.js";
 import { generateOnceNative } from "../../utils/nativeSingleShot.js";
+/**
+ * Filter each contiguous run of text parts as one string.
+ *
+ * A prohibited term that straddles two adjacent text parts is invisible to a
+ * per-part filter, and the parts are concatenated downstream (`lifecycle.ts`
+ * joins adjacent text), so the term reached the caller whole. Anthropic's
+ * native path emits one text part per content block, so adjacent parts are a
+ * real shape, not a theoretical one. Non-text parts keep their position; a run
+ * is rebuilt as a single text part only when the filter changed it.
+ */
+const filterTextRuns = (content, badWords, context) => {
+    const out = [];
+    let run = [];
+    const flushRun = () => {
+        if (run.length === 0) {
+            return;
+        }
+        const merged = run.map((part) => part.text).join("");
+        const filtered = applyContentFiltering(merged, badWords, context);
+        if (filtered.hasChanges) {
+            out.push({ ...run[0], text: filtered.filteredText });
+        }
+        else {
+            out.push(...run);
+        }
+        run = [];
+    };
+    for (const part of content) {
+        if (part.type === "text") {
+            run.push(part);
+        }
+        else {
+            flushRun();
+            out.push(part);
+        }
+    }
+    flushRun();
+    return out;
+};
 /**
  * Create Guardrails AI middleware for content filtering and policy enforcement
  * @param config Configuration for the guardrails middleware
@@ -61,12 +100,7 @@ export function createGuardrailsMiddleware(config = {}) {
             let result = await doGenerate();
             result = {
                 ...result,
-                content: result.content.map((part) => part.type === "text"
-                    ? {
-                        ...part,
-                        text: applyContentFiltering(part.text, config.badWords, "generate").filteredText,
-                    }
-                    : part),
+                content: filterTextRuns(result.content, config.badWords, "generate"),
             };
             if (config.modelFilter?.enabled && config.modelFilter.filterModel) {
                 logger.debug(`[GuardrailsMiddleware] Invoking model-based filter.`);
@@ -113,22 +147,38 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             const { stream, ...rest } = await doStream();
             let hasYieldedChunks = false;
+            // With bad-word filtering on, a text run is buffered and filtered as one
+            // string: a term split across deltas is invisible per delta and every
+            // consumer reassembles it. The run is released when a non-text part
+            // arrives or the stream ends, so the guardrail trades incremental
+            // delivery of that run for not being bypassable by chunking. With
+            // filtering off, deltas pass through untouched and unbuffered.
+            const bufferTextRuns = config.badWords?.enabled === true;
+            let pendingText;
+            const releaseText = (controller) => {
+                if (!pendingText) {
+                    return;
+                }
+                const filtered = applyContentFiltering(pendingText.delta, config.badWords, "stream");
+                controller.enqueue(filtered.hasChanges
+                    ? { ...pendingText, delta: filtered.filteredText }
+                    : pendingText);
+                pendingText = undefined;
+            };
             const transformStream = new TransformStream({
                 transform(chunk, controller) {
                     hasYieldedChunks = true;
-                    let filteredChunk = chunk;
-                    if (filteredChunk.type === "text-delta") {
-                        const filterResult = applyContentFiltering(filteredChunk.delta, config.badWords, "stream");
-                        if (filterResult.hasChanges) {
-                            filteredChunk = {
-                                ...filteredChunk,
-                                delta: filterResult.filteredText,
-                            };
-                        }
+                    if (chunk.type === "text-delta" && bufferTextRuns) {
+                        pendingText = pendingText
+                            ? { ...pendingText, delta: pendingText.delta + chunk.delta }
+                            : chunk;
+                        return;
                     }
-                    controller.enqueue(filteredChunk);
+                    releaseText(controller);
+                    controller.enqueue(chunk);
                 },
-                flush() {
+                flush(controller) {
+                    releaseText(controller);
                     if (!hasYieldedChunks) {
                         logger.warn(`[GuardrailsMiddleware] Stream ended without yielding any chunks`);
                     }

package/dist/neurolink.js

@@ -4359,6 +4359,7 @@ Current user's request: ${currentInput}`;
                 : undefined,
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
+            toolCalls: textResult.toolCalls ?? [],
             toolExecutions: toToolExecutionRecords(textResult.toolExecutions),
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: transformAvailableTools(textResult.availableTools),
@@ -5877,6 +5878,7 @@ Current user's request: ${currentInput}`;
             rawFinishReason: result.rawFinishReason,
             stepsUsed: result.stepsUsed,
             toolsUsed: result.toolsUsed || [],
+            toolCalls: result.toolCalls ?? [],
             toolExecutions: transformedToolExecutions,
             enhancedWithTools: Boolean(hasToolExecutions),
             availableTools: transformToolsForMCP(transformToolsToExpectedFormat(availableTools)),
@@ -6028,6 +6030,7 @@ Current user's request: ${currentInput}`;
                         rawFinishReason: poolResult.rawFinishReason,
                         stepsUsed: poolResult.stepsUsed,
                         toolsUsed: poolResult.toolsUsed || [],
+                        toolCalls: poolResult.toolCalls ?? [],
                         // Lossless pass-through: keep the full ToolExecutionRecord
                         // fields (params/resultText/isError/timing) alongside the
                         // legacy {toolName,executionTime,success} shape this internal
@@ -6398,6 +6401,9 @@ Current user's request: ${currentInput}`;
                     rawFinishReason: result.rawFinishReason,
                     stepsUsed: result.stepsUsed,
                     toolsUsed: result.toolsUsed || [],
+                    // The providers record executed calls; without this line the public
+                    // result never carried them, whatever the provider returned.
+                    toolCalls: result.toolCalls ?? [],
                     // Lossless pass-through: keep the full ToolExecutionRecord fields
                     // alongside the legacy {toolName,executionTime,success} shape this
                     // internal result declares, so the final GenerateResult mapping

package/dist/providers/amazonSagemaker.js

@@ -2,7 +2,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
-import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
@@ -198,6 +198,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed: loop.toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };

package/dist/providers/anthropic/client.js

@@ -28,7 +28,7 @@ import { runAgenticLoop } from "../../core/loopEngine.js";
 import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../../core/nativeGenerateLoop.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { resolveRequestKind } from "../../core/resolveRequestKind.js";
-import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../../core/toolExecutionRecorder.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
@@ -1479,6 +1479,7 @@ export class AnthropicProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed: loop.toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };

package/dist/providers/openaiChatCompletionsBase.js

@@ -34,7 +34,7 @@ import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals,
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
 import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
-import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { coerceJsonToSchema, schemaAccepts } from "../utils/json/coerce.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -989,6 +989,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: toolsUsed.length > 0,
         };

package/dist/types/generate.d.ts

@@ -1490,6 +1490,12 @@ export type TextGenerationResult = {
     model?: string;
     usage?: TokenUsage;
     responseTime?: number;
+    /** The executed tool calls of a native turn — the same shape `GenerateResult` exposes. */
+    toolCalls?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: StandardRecord;
+    }>;
     toolsUsed?: string[];
     toolExecutions?: Array<{
         toolName: string;

package/dist/types/middleware.d.ts

@@ -3,7 +3,7 @@ import type { EvaluationData, GetPromptFunction } from "./evaluation.js";
 import type { AuthenticatedUser, RouteDefinition, ServerContext } from "./server.js";
 import type { LanguageModelMiddleware as BaseLanguageModelMiddleware } from "./aiCompat.js";
 export type { LanguageModelMiddleware } from "./aiCompat.js";
-export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Message, LanguageModelV3Prompt, LanguageModelV3StreamPart, LanguageModelV3ToolCall, LanguageModelV3ToolChoice, LanguageModelV3Source, LanguageModelV3Middleware, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, JSONSchema7, } from "./aiCompat.js";
+export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Message, LanguageModelV3Prompt, LanguageModelV3StreamPart, LanguageModelV3Content, LanguageModelV3ToolCall, LanguageModelV3ToolChoice, LanguageModelV3Source, LanguageModelV3Middleware, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, JSONSchema7, } from "./aiCompat.js";
 /**
  * Metadata type for NeuroLink middleware
  * Provides additional information about middleware without affecting execution

package/dist/utils/schemaConversion.d.ts

@@ -49,6 +49,15 @@ export declare function normalizeWireToolSchema(schema: unknown): Record<string,
  * Check if a value is a Zod schema
  */
 export declare function isZodSchema(value: unknown): boolean;
+/**
+ * Whether a schema was built by Zod 4 specifically.
+ *
+ * Zod 4 hangs its internals off `_zod` (and `z.toJSONSchema` reads
+ * `schema._zod.def`); Zod 3 has only `_def`. The two can coexist in one install
+ * — a host on Zod 3 still resolves NeuroLink's own Zod 4 — so the presence of
+ * `z.toJSONSchema` says nothing about the schema actually being handed to it.
+ */
+export declare function isZod4Schema(value: unknown): boolean;
 /**
  * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
  * This ensures complete preservation of all schema structure and validation rules

package/dist/utils/schemaConversion.js

@@ -340,7 +340,7 @@ target = "jsonSchema7") {
     // Translate our `target` to Zod 4's native dialect identifier so the
     // openApi3 path emits the OpenAPI 3 schema shape Vertex/Gemini expect
     // (and not the default draft-07 anyOf/null union).
-    if (zodToJsonSchemaV4) {
+    if (zodToJsonSchemaV4 && isZod4Schema(zodSchema)) {
         const nativeTarget = target === "openApi3" ? "openapi-3.0" : "draft-07";
         try {
             const native = zodToJsonSchemaV4(zodSchema, {
@@ -572,6 +572,17 @@ export function isZodSchema(value) {
         "_def" in value &&
         typeof value.parse === "function");
 }
+/**
+ * Whether a schema was built by Zod 4 specifically.
+ *
+ * Zod 4 hangs its internals off `_zod` (and `z.toJSONSchema` reads
+ * `schema._zod.def`); Zod 3 has only `_def`. The two can coexist in one install
+ * — a host on Zod 3 still resolves NeuroLink's own Zod 4 — so the presence of
+ * `z.toJSONSchema` says nothing about the schema actually being handed to it.
+ */
+export function isZod4Schema(value) {
+    return !!(value && typeof value === "object" && "_zod" in value);
+}
 /**
  * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
  * This ensures complete preservation of all schema structure and validation rules

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.7",
+  "version": "12.12.9",
   "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": {
@@ -96,6 +96,7 @@
     "test:openai-compat-streaming-retry": "pnpm exec tsx test/continuous-test-suite-openai-compat-streaming-retry.ts",
     "test:anthropic-streaming-retry": "pnpm exec tsx test/continuous-test-suite-anthropic-streaming-retry.ts",
     "test:adjust-body-after-400": "pnpm exec tsx test/continuous-test-suite-adjust-body-after-400.ts",
+    "test:zod3-schema-native-path": "pnpm exec tsx test/continuous-test-suite-zod3-schema-native-path.ts",
     "test:error-classification-e2e": "pnpm exec tsx test/continuous-test-suite-error-classification-e2e.ts",
     "test:error-classifier-contract": "pnpm exec tsx test/continuous-test-suite-error-classifier-contract.ts",
     "test:bedrock-inference-profile": "pnpm exec tsx test/continuous-test-suite-bedrock-inference-profile.ts",
@@ -112,6 +113,7 @@
     "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",
+    "test:browser-bundle": "pnpm exec tsx test/continuous-test-suite-browser-bundle.ts",
     "test:providers-mocked": "pnpm exec tsx test/continuous-test-suite-providers-mocked.ts",
     "scaffold:provider": "pnpm exec tsx tools/scaffold-provider.ts",
     "verify:provider-onboarding": "pnpm exec tsx tools/verify-provider-onboarding.ts",