@juspay/neurolink 10.12.8 → 11.0.0

package/dist/lib/neurolink.js

@@ -74,7 +74,7 @@ import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableErr
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
-import { coerceJsonToSchema } from "./utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "./utils/json/coerce.js";
 // Factory processing imports
 import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
 import { logger, mcpLogger } from "./utils/logger.js";
@@ -4058,52 +4058,85 @@ Current user's request: ${currentInput}`;
         }
         return textOptions;
     }
-    finalizeGenerateRequestResult(params) {
-        const { generateSpan, options, textOptions, textResult, factoryResult, originalPrompt, startTime, } = params;
-        // Provider-agnostic JSON coercion for schema requests. Structured-output
-        // enforcement makes valid JSON the overwhelming case; for every other
-        // provider path — including generate() overrides (Vertex, Anthropic,
-        // Bedrock, Google AI Studio) — object/array roots are recovered here via
-        // balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
-        // with the parsed value exposed as `structuredData`. If nothing
-        // JSON-shaped is recoverable (pure prose), the raw text is returned,
-        // `structuredData` stays undefined, and a WARN makes the case observable.
-        // Runs BEFORE the end-of-generation emits below so event consumers see
-        // the same coerced content/structuredData the caller receives.
-        if (textOptions.schema &&
-            textResult.structuredData === undefined &&
-            typeof textResult.content === "string") {
-            const coerced = coerceJsonToSchema(textResult.content, textOptions.schema);
-            if (coerced) {
-                textResult.content = coerced.content;
-                textResult.structuredData = coerced.structuredData;
-                if (coerced.repaired) {
-                    textResult.jsonRepaired = true;
-                }
-                if (coerced.truncated) {
-                    textResult.jsonTruncated = true;
-                }
+    /**
+     * Provider-agnostic JSON recovery for schema requests. Structured-output
+     * enforcement makes valid JSON the overwhelming case; for every other
+     * provider path — including generate() overrides (Vertex, Anthropic,
+     * Bedrock, Google AI Studio) — object/array roots are recovered here via
+     * balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
+     * with the parsed value exposed as `structuredData`. If nothing JSON-shaped
+     * is recoverable (pure prose), the raw text is returned, `structuredData`
+     * stays undefined, and a WARN makes the case observable.
+     *
+     * Mutates `textResult` in place, and must run BEFORE the end-of-generation
+     * emits so event consumers see the same content/structuredData the caller
+     * receives.
+     */
+    recoverStructuredData(textResult, schema) {
+        // A provider path that produced its own `structuredData` normally owns it.
+        // The one exception is a STRING the caller's schema rejects: that is the
+        // raw completion leaking through as structured output (the shape a
+        // truncated response degrades to), so re-run recovery over the text rather
+        // than handing back a value the declared schema forbids.
+        const structuredIsRejectedString = typeof textResult.structuredData === "string" &&
+            !schemaAccepts(schema, textResult.structuredData);
+        if (!schema ||
+            (textResult.structuredData !== undefined &&
+                !structuredIsRejectedString) ||
+            typeof textResult.content !== "string") {
+            return;
+        }
+        if (structuredIsRejectedString) {
+            textResult.structuredData = undefined;
+        }
+        const coerced = coerceJsonToSchema(textResult.content, schema);
+        if (coerced) {
+            textResult.content = coerced.content;
+            textResult.structuredData = coerced.structuredData;
+            if (coerced.repaired) {
+                textResult.jsonRepaired = true;
             }
-            else {
-                try {
-                    const scalar = JSON.parse(textResult.content);
-                    if (scalar === "") {
-                        // A JSON-encoded empty string is an EMPTY completion, not a
-                        // recovered scalar — normalize to a true empty so callers'
-                        // empty-response handling fires instead of a literal '""'
-                        // reaching the user. `structuredData` stays undefined.
-                        textResult.content = "";
-                        logger.warn("[NeuroLink] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: textResult.provider, model: textResult.model });
-                    }
-                    else if (scalar !== null && scalar !== undefined) {
-                        textResult.structuredData = scalar;
-                    }
-                }
-                catch {
-                    logger.warn("[NeuroLink] schema requested but no JSON could be recovered from model output; returning raw text", { provider: textResult.provider, model: textResult.model });
-                }
+            if (coerced.truncated) {
+                textResult.jsonTruncated = true;
             }
+            return;
         }
+        const scalar = recoverScalarRoot(textResult.content, schema);
+        switch (scalar.kind) {
+            case "empty":
+                // A JSON-encoded empty string is an EMPTY completion, not a recovered
+                // scalar — normalize to a true empty so callers' empty-response
+                // handling fires instead of a literal '""' reaching the user.
+                // `structuredData` stays undefined.
+                textResult.content = "";
+                logger.warn("[NeuroLink] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: textResult.provider, model: textResult.model });
+                break;
+            case "accepted":
+                // Only publish a scalar root the caller's schema actually accepts.
+                // Under an OBJECT schema a recovered string is the raw completion in
+                // disguise — the shape a truncated response degrades to — and exposing
+                // it hands the caller a `structuredData` that violates the schema they
+                // passed.
+                textResult.structuredData = scalar.value;
+                break;
+            case "rejected":
+                logger.warn("[NeuroLink] recovered a JSON scalar the requested schema rejects; leaving structuredData unset", {
+                    provider: textResult.provider,
+                    model: textResult.model,
+                    scalarType: typeof scalar.value,
+                });
+                break;
+            case "nullish":
+                // JSON null/undefined — no structured value to publish.
+                break;
+            case "not-json":
+                logger.warn("[NeuroLink] schema requested but no JSON could be recovered from model output; returning raw text", { provider: textResult.provider, model: textResult.model });
+                break;
+        }
+    }
+    finalizeGenerateRequestResult(params) {
+        const { generateSpan, options, textOptions, textResult, factoryResult, originalPrompt, startTime, } = params;
+        this.recoverStructuredData(textResult, textOptions.schema);
         // Surface truncation when a schema was requested: either the provider
         // reported finishReason="length" or the recovered JSON came from an
         // unclosed span. Either way `structuredData` may be incomplete — warn at

package/dist/lib/providers/anthropic/client.js

@@ -1206,6 +1206,9 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 const content = [];
                 let finalResultText;
+                // Text emitted in forced-json mode, kept only as a fallback (see below).
+                const jsonModeText = [];
+                let jsonToolAnswered = false;
                 for (const block of response.content) {
                     if (block.type === "thinking") {
                         content.push({ type: "reasoning", text: block.thinking });
@@ -1213,13 +1216,17 @@ export class AnthropicProvider extends BaseProvider {
                     else if (block.type === "text") {
                         // In forced-json mode the payload arrives via the tool input, not
                         // text — pass text through only in normal mode.
-                        if (!jsonTool) {
+                        if (jsonTool) {
+                            jsonModeText.push(block.text);
+                        }
+                        else {
                             content.push({ type: "text", text: block.text });
                         }
                     }
                     else if (block.type === "tool_use") {
                         if (jsonTool && block.name === jsonTool) {
                             // Unwrap the synthetic tool call back into text JSON.
+                            jsonToolAnswered = true;
                             content.push({
                                 type: "text",
                                 text: stringifyToolInput(block.input),
@@ -1241,6 +1248,15 @@ export class AnthropicProvider extends BaseProvider {
                         }
                     }
                 }
+                // Forced-json mode normally drops text blocks because the payload rides
+                // in the synthetic tool's input. But when the response is cut short
+                // (stop_reason "max_tokens") the tool call can be missing entirely, and
+                // dropping the text would leave an EMPTY completion with nothing for
+                // coerceJsonToSchema to recover. Fall back to the text so a partial
+                // object can still be salvaged and flagged truncated.
+                if (jsonTool && !jsonToolAnswered && jsonModeText.length > 0) {
+                    content.push({ type: "text", text: jsonModeText.join("") });
+                }
                 // final_result is terminal — parity with the native Claude-on-Vertex
                 // and Gemini loops, which break out of the tool loop the moment it
                 // arrives. Reasoning blocks are kept; any prose preamble and any tool

package/dist/lib/providers/anthropic/constants.d.ts

@@ -1,4 +1,3 @@
 export declare const ANTHROPIC_BETA_HEADERS: {
     "anthropic-beta": string;
 };
-export declare const streamTracer: import("@opentelemetry/api").Tracer;

package/dist/lib/providers/anthropic/constants.js

@@ -1,9 +1,7 @@
-import { trace } from "@opentelemetry/api";
 export const ANTHROPIC_BETA_HEADERS = {
     "anthropic-beta": [
         "claude-code-20250219",
         "fine-grained-tool-streaming-2025-05-14",
     ].join(","),
 };
-export const streamTracer = trace.getTracer("neurolink.provider.anthropic");
 //# sourceMappingURL=constants.js.map

package/dist/lib/providers/anthropic/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";

package/dist/lib/providers/anthropic/index.js

@@ -1,4 +1,3 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/providers/googleAiStudio/index.d.ts

@@ -1,2 +1 @@
 export * from "./client.js";
-export * from "./utils.js";

package/dist/lib/providers/googleAiStudio/index.js

@@ -1,3 +1,2 @@
 export * from "./client.js";
-export * from "./utils.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/providers/googleNativeGemini3/index.d.ts

@@ -1,2 +1 @@
-export * from "./constants.js";
 export * from "./utils.js";

package/dist/lib/providers/googleNativeGemini3/index.js

@@ -1,3 +1,2 @@
-export * from "./constants.js";
 export * from "./utils.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/providers/googleVertex/client.d.ts

@@ -70,28 +70,6 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Creates fresh model instances for each request
      */
     protected getAISDKModel(): Promise<LanguageModel>;
-    /**
-     * Initialize model creation tracking
-     */
-    private initializeModelCreationLogging;
-    /**
-     * Check if model is Anthropic-based and attempt creation
-     */
-    private attemptAnthropicModelCreation;
-    /**
-     * Create Google Vertex model with comprehensive logging and error handling
-     */
-    private createGoogleVertexModel;
-    /**
-     * @deprecated This method is no longer used. All models now use native SDKs.
-     */
-    private createVertexInstance;
-    /**
-     * Gets the appropriate model instance (Google or Anthropic)
-     * Uses dual provider architecture for proper model routing
-     * Creates fresh instances for each request to ensure proper authentication
-     */
-    private getModel;
     /**
      * Validate stream options
      */
@@ -320,35 +298,6 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns Promise<boolean> indicating if Anthropic support is available
      */
     hasAnthropicSupport(): Promise<boolean>;
-    /**
-     * @deprecated This method is no longer used. Claude models now use native @anthropic-ai/vertex-sdk
-     * via executeNativeAnthropicStream and executeNativeAnthropicGenerate.
-     */
-    createAnthropicModel(_modelName: string): Promise<LanguageModel | null>;
-    /**
-     * Validate Vertex AI authentication configuration
-     */
-    private validateVertexAuthentication;
-    /**
-     * Validate Vertex AI project configuration
-     */
-    private validateVertexProjectConfiguration;
-    /**
-     * Check if the specified region supports Anthropic models
-     */
-    private checkVertexRegionalSupport;
-    /**
-     * Validate Anthropic model name format and availability
-     */
-    private validateAnthropicModelName;
-    /**
-     * Analyze Anthropic model creation errors for detailed troubleshooting
-     */
-    private analyzeAnthropicCreationError;
-    /**
-     * Get detailed troubleshooting steps based on error analysis
-     */
-    private getAnthropicTroubleshootingSteps;
     /**
      * Register a tool with the AI provider
      * @param name The name of the tool