@juspay/neurolink 10.6.0 → 10.6.2

package/dist/server/utils/redaction.js

@@ -80,13 +80,13 @@ function redactChunkByType(chunk, redactedFields, placeholder, config) {
     const chunkType = typedChunk.type;
     switch (chunkType) {
         case "step-start":
-            return redactStepStart(typedChunk, redactedFields, placeholder);
+            return redactStepStart(chunk, redactedFields, placeholder);
         case "tool-call":
-            return redactToolCall(typedChunk, redactedFields, placeholder, config);
+            return redactToolCall(chunk, redactedFields, placeholder, config);
         case "tool-result":
-            return redactToolResult(typedChunk, redactedFields, placeholder, config);
+            return redactToolResult(chunk, redactedFields, placeholder, config);
         case "error":
-            return redactError(typedChunk, redactedFields, placeholder);
+            return redactError(chunk, redactedFields, placeholder);
         default:
             return redactGenericChunk(typedChunk, redactedFields, placeholder);
     }
@@ -99,13 +99,12 @@ function redactStepStart(chunk, redactedFields, placeholder) {
         return chunk;
     }
     const { payload, ...rest } = chunk;
-    const payloadObj = payload;
-    const redactedPayload = redactObject(payloadObj, redactedFields, placeholder, 0);
-    return {
+    const redactedPayload = redactObject(payload, redactedFields, placeholder, 0);
+    const redacted = {
         ...rest,
-        type: "step-start",
         payload: redactedPayload,
     };
+    return redacted;
 }
 /**
  * Redact tool-call chunks
@@ -114,49 +113,45 @@ function redactToolCall(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
         // Redact tool arguments if configured
-        if (payloadObj.toolCall && typeof payloadObj.toolCall === "object") {
-            const toolCall = payloadObj.toolCall;
+        if (payload.toolCall && typeof payload.toolCall === "object") {
+            const toolCall = payload.toolCall;
             const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
-            return {
+            const redacted = {
                 ...rest,
-                type: "tool-call",
                 payload: {
-                    ...payloadObj,
+                    ...payload,
                     toolCall: {
                         ...toolCall,
                         args: redactArgs ? placeholder : toolCall.args,
                     },
                 },
             };
+            return redacted;
         }
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-call",
-            payload: redactObject(payloadObj, redactedFields, placeholder, 0),
+            payload: redactObject(payload, redactedFields, placeholder, 0),
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
         // Check for arguments field in data
-        if ("arguments" in dataObj && redactArgs) {
+        if ("arguments" in data && redactArgs) {
             return {
                 ...rest,
-                type: "tool-call",
                 data: {
-                    ...dataObj,
+                    ...data,
                     arguments: placeholder,
                 },
             };
         }
         return {
             ...rest,
-            type: "tool-call",
-            data: redactObject(dataObj, redactedFields, placeholder, 0),
+            data: redactObject(data, redactedFields, placeholder, 0),
         };
     }
     return chunk;
@@ -169,26 +164,23 @@ function redactToolResult(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-result",
             payload: {
-                ...payloadObj,
-                result: redactResult ? placeholder : payloadObj.result,
+                ...payload,
+                result: redactResult ? placeholder : payload.result,
             },
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         return {
             ...rest,
-            type: "tool-result",
             data: {
-                ...dataObj,
-                result: redactResult ? placeholder : dataObj.result,
+                ...data,
+                result: redactResult ? placeholder : data.result,
             },
         };
     }
@@ -202,11 +194,9 @@ function redactError(chunk, redactedFields, placeholder) {
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
-        const { stack, ...dataRest } = dataObj;
+        const { stack, ...dataRest } = data;
         return {
             ...rest,
-            type: "error",
             data: {
                 ...redactObject(dataRest, redactedFields, placeholder, 0),
                 ...(isProduction ? {} : { stack }),
@@ -214,7 +204,8 @@ function redactError(chunk, redactedFields, placeholder) {
         };
     }
     // Handle direct chunk with stack
-    const { stack, ...restChunk } = chunk;
+    const chunkRecord = chunk;
+    const { stack, ...restChunk } = chunkRecord;
     const redactedRest = redactObject(restChunk, redactedFields, placeholder, 0);
     return {
         ...redactedRest,
@@ -270,9 +261,10 @@ function redactObject(obj, redactedFields, placeholder, depth) {
  * Type guard for chunks with payload
  */
 function hasPayload(chunk) {
-    return ("payload" in chunk &&
-        chunk.payload !== null &&
-        typeof chunk.payload === "object");
+    const record = chunk;
+    return ("payload" in record &&
+        record.payload !== null &&
+        typeof record.payload === "object");
 }
 /**
  * Type guard for chunks with data (DataStreamEvent format)

package/dist/server/websocket/WebSocketHandler.js

@@ -334,17 +334,17 @@ export function createAgentWebSocketHandler(_neurolink) {
     // Register message routes
     router.route("generate", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement generate using neurolink
+        // TODO(#1179): Implement generate using neurolink
         return { type: "response", data: `Received: ${prompt}` };
     });
     router.route("stream", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement streaming using neurolink
+        // TODO(#1179): Implement streaming using neurolink
         return { type: "stream_start", data: { prompt } };
     });
     router.route("tool_call", async (connection, payload) => {
         const { toolName, args: _args } = payload;
-        // TODO: Implement tool call using neurolink
+        // TODO(#1179): Implement tool call using neurolink
         return { type: "tool_result", data: { toolName, result: null } };
     });
     return {

package/dist/services/server/ai/observability/instrumentation.js

@@ -225,6 +225,7 @@ class ContextEnricher {
         const userId = context?.userId ?? currentConfig?.userId ?? "guest";
         const sessionId = context?.sessionId ?? currentConfig?.sessionId;
         // Get span name for operation auto-detection
+        // (sdk-trace-base's Span type includes the ReadableSpan members)
         const spanName = span.name;
         // Determine if auto-detection is enabled for this context
         const autoDetect = this.shouldAutoDetectOperationName(context);
@@ -386,9 +387,11 @@ class ContextEnricher {
      */
     onEnd(span) {
         try {
-            // Get span attributes (ReadableSpan interface)
-            const readableSpan = span;
-            const attributes = readableSpan.attributes || {};
+            // Get span attributes (sdk-trace-base's Span type includes the
+            // ReadableSpan members, so attributes/name/status are directly typed).
+            // Keep the {} fallback: this processor can be attached to an external
+            // app-owned TracerProvider whose span implementation may omit attributes.
+            const attributes = span.attributes ?? {};
             // Handle wrapper/trace-root spans: update trace name with detected operation
             // This supports host apps (like Curator) that create wrapper spans before AI calls
             // This is optional - if spanContext fails, we skip wrapper span support
@@ -437,7 +440,7 @@ class ContextEnricher {
                 const provider = attributes["gen_ai.system"] ||
                     attributes["ai.model.provider"];
                 logger.debug(`${LOG_PREFIX} GenAI span detected`, {
-                    spanName: readableSpan.name,
+                    spanName: span.name,
                     model,
                     provider,
                 });
@@ -529,7 +532,7 @@ class ContextEnricher {
                 // *returns* { isError:true } (no exception thrown), so Langfuse sees
                 // level=DEFAULT and no status message. Parse the stringified result
                 // and surface the embedded error text.
-                if (readableSpan.name === "ai.toolCall" &&
+                if (span.name === "ai.toolCall" &&
                     readableStatus?.code !== SpanStatusCode.ERROR) {
                     applyToolCallIsErrorStatus(mutableAttrs);
                 }

package/dist/types/classifierRouter.d.ts

@@ -13,6 +13,7 @@
  * Type names are domain-prefixed `Classifier*` to stay globally unique across
  * `src/lib/types/` (see CLAUDE.md rule 9).
  */
+import type { ValidationSchema } from "./aliases.js";
 /** Coarse difficulty buckets the classifier maps a request into. */
 export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
 /** Which classification strategy to run. */
@@ -166,7 +167,7 @@ export type ClassifierGenerateOptions = {
     temperature?: number;
     maxTokens?: number;
     disableTools?: boolean;
-    schema?: unknown;
+    schema?: ValidationSchema;
     timeout?: number | string;
     context?: Record<string, unknown>;
 };

package/dist/types/providers.d.ts

@@ -2,6 +2,7 @@
  * Provider-specific type definitions for NeuroLink
  */
 import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
+import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
@@ -1669,8 +1670,8 @@ export type ToolWithLegacyParams = {
  * factory functions.
  */
 export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
 /** Provider registration entry held by ProviderFactory. */
 export type ProviderRegistration = {
     constructor: ProviderConstructor;
@@ -1779,6 +1780,25 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Part variants that ride the native Gemini agentic tool loop in addition to
+ * the plain `VertexNativePart` content shapes: model-issued function calls
+ * replayed into history, and the function responses (plus wrap-up nudge text
+ * parts) sent back on the next user turn. Mirrors the optional
+ * `functionCall` / `functionResponse` members of the @google/genai SDK's
+ * `Part` type, so loop contents stay directly assignable to the SDK payload.
+ */
+export type VertexNativeLoopPart = VertexNativePart | {
+    functionCall: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+} | {
+    functionResponse: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+};
 /**
  * Subset of `GenerateOptions["input"]` consumed by the shared Gemini-native
  * multimodal-parts builder. Kept narrow so the helper doesn't depend on the

package/dist/utils/pdfProcessor.js

@@ -264,6 +264,8 @@ export class PDFProcessor {
                     clearTimeout(timeoutHandle);
                 }
                 try {
+                    // Optional call: guards against a runtime pdf-parse version whose
+                    // instances lack destroy(), while the typed v2 class declares it.
                     await pdf.destroy?.();
                 }
                 catch {

package/dist/utils/safeFetch.js

@@ -58,6 +58,23 @@ function buildPinnedAgent(hostname, addresses) {
         },
     });
 }
+/**
+ * Runtime-validating narrow across the undici → DOM `Response` type boundary.
+ * `readBoundedBuffer` only touches `headers.get()` and `arrayBuffer()`; the
+ * two libraries' `Response` declarations disagree on unrelated members
+ * (headers iterator shapes), so validate the members actually used instead
+ * of blindly asserting.
+ */
+function isBoundedBufferResponse(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.arrayBuffer === "function" &&
+        typeof candidate.headers === "object" &&
+        candidate.headers !== null &&
+        typeof candidate.headers.get === "function");
+}
 /**
  * Safely download a binary asset from an external URL.
  *
@@ -96,5 +113,8 @@ export async function safeDownload(url, options) {
     }
     // readBoundedBuffer expects a Response that exposes Content-Length and
     // arrayBuffer(). undici Response satisfies both.
+    if (!isBoundedBufferResponse(response)) {
+        throw new Error(`safeDownload(${options.label}): response is missing headers.get()/arrayBuffer()`);
+    }
     return readBoundedBuffer(response, options.maxBytes, options.label);
 }

package/dist/utils/schemaConversion.d.ts

@@ -27,7 +27,7 @@ export declare function ensureNestedSchemaTypes(schema: Record<string, unknown>)
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema, target?: "jsonSchema7" | "openApi3"): object;
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema | Record<string, unknown>, target?: "jsonSchema7" | "openApi3"): object;
 export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Normalize a JSON Schema for the OpenAI chat-completions `tools` wire

package/dist/utils/schemaConversion.js

@@ -308,7 +308,10 @@ export function ensureNestedSchemaTypes(schema) {
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export function convertZodToJsonSchema(zodSchema, 
+export function convertZodToJsonSchema(
+// The union mirrors the three documented input shapes: Zod schemas plus
+// plain-object forms (AI SDK `jsonSchema()` wrappers and raw JSON Schema).
+zodSchema, 
 // Default to JSON Schema draft-07 so non-Vertex consumers (Bedrock, MCP
 // tool registration, etc.) keep their pre-migration dialect. Vertex/Gemini
 // callers opt into "openApi3" explicitly to get `nullable: true` instead
@@ -360,6 +363,7 @@ target = "jsonSchema7") {
     try {
         // Zod 4→3 boundary: zodToJsonSchema types reference Zod 3's ZodSchema via zod/v3.
         // Runtime compatible — cast through unknown at this third-party boundary only.
+        // eslint-disable-next-line no-restricted-syntax -- genuine third-party type-system boundary: zod-to-json-schema's input type is zod/v3's ZodType, structurally incompatible with the Zod 4 schema held here (no overlap, single assertion cannot compile); runtime-compatible fallback contract documented above.
         const zodV3Schema = zodSchema;
         const jsonSchema = zodToJsonSchema(zodV3Schema, {
             name: "ToolParameters",

package/dist/workflow/config.d.ts

@@ -140,8 +140,8 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
     type: z.ZodEnum<{
         custom: "custom";
         chain: "chain";
-        adaptive: "adaptive";
         ensemble: "ensemble";
+        adaptive: "adaptive";
     }>;
     models: z.ZodArray<z.ZodObject<{
         provider: z.ZodType<AIProviderName, unknown, z.core.$ZodTypeInternals<AIProviderName, unknown>>;
@@ -368,7 +368,7 @@ export declare function hasJudge(config: WorkflowConfig): boolean;
 export declare function getAllJudges(config: WorkflowConfig): JudgeConfig[];
 /**
  * Calculate estimated workflow cost (placeholder)
- * TODO: Implement actual provider-specific pricing
+ * TODO(#1179): Implement actual provider-specific pricing
  * @param config - Workflow configuration
  * @param estimatedTokens - Estimated number of tokens for the request
  * @returns Estimated cost in USD

package/dist/workflow/config.js

@@ -383,7 +383,7 @@ export function getAllJudges(config) {
 }
 /**
  * Calculate estimated workflow cost (placeholder)
- * TODO: Implement actual provider-specific pricing
+ * TODO(#1179): Implement actual provider-specific pricing
  * @param config - Workflow configuration
  * @param estimatedTokens - Estimated number of tokens for the request
  * @returns Estimated cost in USD

package/dist/workflow/core/workflowRegistry.js

@@ -10,7 +10,7 @@ const functionTag = "WorkflowRegistry";
 // ============================================================================
 /**
  * In-memory workflow registry
- * TODO: Consider persistent storage in future phases
+ * TODO(#1179): Consider persistent storage in future phases
  */
 const workflowRegistry = new Map();
 // ============================================================================

package/dist/workflow/core/workflowRunner.js

@@ -158,7 +158,7 @@ export async function runWorkflow(config, options) {
                     totalInputTokens: calculateInputTokens(ensembleResult.responses),
                     totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
                     totalTokens: calculateTotalTokens(ensembleResult.responses),
-                    byModel: [], // TODO: Populate per-model breakdown
+                    byModel: [], // TODO(#1179): Populate per-model breakdown
                 },
                 // Additional metadata
                 metadata: options.metadata,

package/dist/workflow/utils/workflowMetrics.d.ts

@@ -46,7 +46,7 @@ export declare function calculateModelMetrics(responses: EnsembleResponse[]): Re
 /**
  * Calculate consensus level between responses
  * NOTE: Placeholder implementation - uses response length similarity
- * TODO: Implement semantic similarity in Phase 2
+ * TODO(#1179): Implement semantic similarity in Phase 2
  */
 export declare function calculateConsensus(responses: EnsembleResponse[]): number;
 /**

package/dist/workflow/utils/workflowMetrics.js

@@ -159,7 +159,7 @@ export function calculateModelMetrics(responses) {
 /**
  * Calculate consensus level between responses
  * NOTE: Placeholder implementation - uses response length similarity
- * TODO: Implement semantic similarity in Phase 2
+ * TODO(#1179): Implement semantic similarity in Phase 2
  */
 export function calculateConsensus(responses) {
     const successful = responses.filter((r) => r.status === "success");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.6.0",
+  "version": "10.6.2",
   "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": {