@juspay/neurolink 9.70.0 → 9.70.2

package/dist/utils/json/coerce.js

@@ -0,0 +1,140 @@
+/**
+ * Coerce arbitrary model text into canonical, syntactically-valid JSON.
+ *
+ * Used on the text-mode path (providers/models that could not use AI-SDK
+ * structured output, e.g. real Gemini + tools). The model hand-writes JSON and
+ * frequently mis-escapes the content field (bare newline, unescaped quote,
+ * invalid escape like \d). A balanced-brace scan finds the object span; if
+ * JSON.parse rejects it, jsonrepair fixes common escaping mistakes; the result
+ * is re-serialised with JSON.stringify so downstream consumers always receive
+ * valid JSON.
+ *
+ * NOTE: jsonrepair is a heuristic. On content where a lone backslash is
+ * meaningful (regex/script/Windows path) it may drop the backslash, producing
+ * valid-but-semantically-altered content. This only affects the residual
+ * text-mode path — the primary Vertex+Claude path uses experimental_output and
+ * never reaches here. When jsonrepair changes the input we log at debug level
+ * so the event is observable.
+ */
+import { jsonrepair } from "jsonrepair";
+import { logger } from "../logger.js";
+import { nextBalancedJsonSpan } from "./extract.js";
+/** True when the schema exposes a Zod-style `safeParse` we can validate with. */
+function hasSafeParse(schema) {
+    return typeof schema.safeParse === "function";
+}
+/**
+ * Parse `candidate` as JSON, repairing common escaping mistakes on failure.
+ * Returns the parsed value plus whether jsonrepair had to alter the text.
+ */
+function parseOrRepair(candidate) {
+    try {
+        return { value: JSON.parse(candidate), repaired: false };
+    }
+    catch {
+        // fall through to repair
+    }
+    try {
+        const repaired = jsonrepair(candidate);
+        const value = JSON.parse(repaired);
+        if (repaired !== candidate && logger.shouldLog("debug")) {
+            logger.debug("[coerceJsonToSchema] jsonrepair altered model output", {
+                originalLength: candidate.length,
+                repairedLength: repaired.length,
+            });
+        }
+        return { value, repaired: repaired !== candidate };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Try to produce canonical JSON from `text`. Returns null when no JSON object
+ * could be recovered (caller should then keep the raw text).
+ *
+ * When `schema` is a Zod schema, candidates that satisfy it are preferred; a
+ * syntactically-valid-but-schema-failing object is still returned (we guarantee
+ * JSON *validity*, leaving schema/content checks to the caller's own pipeline).
+ */
+export function coerceJsonToSchema(text, schema) {
+    if (typeof text !== "string" || text.trim().length === 0) {
+        return null;
+    }
+    // Ordered candidate substrings, best-formed first:
+    //  1. every balanced object/array span (clean, common case)
+    //  2. first "{" or "[" to last "}" or "]" (drops surrounding prose; lets
+    //     jsonrepair fix escaping inside) — root ARRAYS matter for array schemas
+    //  3. first "{" or "[" to end of text (TRUNCATED output —
+    //     finishReason=length — where the closing bracket was cut off;
+    //     jsonrepair closes it)
+    // `truncated` marks the first-open-to-end candidate: it is only reachable
+    // when no balanced span and no first-to-last span matched, i.e. there was no
+    // closing bracket at all — the signature of token-truncated output.
+    const candidates = [];
+    let searchFrom = 0;
+    for (;;) {
+        const found = nextBalancedJsonSpan(text, searchFrom);
+        if (!found) {
+            break;
+        }
+        candidates.push({ text: found.span, truncated: false });
+        searchFrom = found.end;
+    }
+    const openIndexes = [text.indexOf("{"), text.indexOf("[")].filter((i) => i >= 0);
+    const firstOpen = openIndexes.length > 0 ? Math.min(...openIndexes) : -1;
+    const lastClose = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
+    if (firstOpen >= 0 && lastClose > firstOpen) {
+        candidates.push({
+            text: text.slice(firstOpen, lastClose + 1),
+            truncated: false,
+        });
+    }
+    if (firstOpen >= 0) {
+        candidates.push({ text: text.slice(firstOpen), truncated: true });
+    }
+    let firstValid;
+    let schemaMatch;
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate.text)) {
+            continue;
+        }
+        seen.add(candidate.text);
+        const outcome = parseOrRepair(candidate.text);
+        if (outcome === undefined ||
+            outcome.value === null ||
+            typeof outcome.value !== "object") {
+            continue;
+        }
+        const record = {
+            value: outcome.value,
+            repaired: outcome.repaired,
+            truncated: candidate.truncated,
+        };
+        if (firstValid === undefined) {
+            firstValid = record;
+        }
+        if (schema && hasSafeParse(schema)) {
+            const safeParseable = schema;
+            if (safeParseable.safeParse(outcome.value).success) {
+                schemaMatch = record;
+                break;
+            }
+        }
+        else {
+            // No Zod schema to discriminate — first parseable object wins.
+            break;
+        }
+    }
+    const chosen = schemaMatch ?? firstValid;
+    if (chosen === undefined) {
+        return null;
+    }
+    return {
+        content: JSON.stringify(chosen.value),
+        structuredData: chosen.value,
+        repaired: chosen.repaired,
+        truncated: chosen.truncated,
+    };
+}

package/dist/utils/json/extract.d.ts

@@ -4,6 +4,16 @@
  * Utilities for extracting JSON from mixed text content.
  * Particularly useful for parsing AI responses that contain JSON within prose.
  */
+/**
+ * Find the first balanced JSON object/array span starting at or after
+ * `fromIndex`. Quote- and escape-aware: braces inside string literals do not
+ * affect depth. Returns the matched substring and the index just past it, or
+ * null if no balanced span exists.
+ */
+export declare function nextBalancedJsonSpan(text: string, fromIndex?: number): {
+    span: string;
+    end: number;
+} | null;
 /**
  * Extract JSON string from text that may contain surrounding content.
  *

package/dist/utils/json/extract.js

@@ -5,6 +5,53 @@
  * Particularly useful for parsing AI responses that contain JSON within prose.
  */
 import { parseJsonOrNull } from "./safeParse.js";
+/**
+ * Find the first balanced JSON object/array span starting at or after
+ * `fromIndex`. Quote- and escape-aware: braces inside string literals do not
+ * affect depth. Returns the matched substring and the index just past it, or
+ * null if no balanced span exists.
+ */
+export function nextBalancedJsonSpan(text, fromIndex = 0) {
+    for (let start = fromIndex; start < text.length; start++) {
+        const openChar = text[start];
+        if (openChar !== "{" && openChar !== "[") {
+            continue;
+        }
+        const closeChar = openChar === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = start; i < text.length; i++) {
+            const ch = text[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escapeNext = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (ch === openChar) {
+                depth++;
+            }
+            else if (ch === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    return { span: text.substring(start, i + 1), end: i + 1 };
+                }
+            }
+        }
+        // Unbalanced from this start — try the next opening char.
+    }
+    return null;
+}
 /**
  * Extract JSON string from text that may contain surrounding content.
  *
@@ -45,21 +92,24 @@ export function extractJsonStringFromText(text) {
             // Continue to other patterns
         }
     }
-    // Try to find JSON object or array pattern using non-greedy iterative scan.
-    // Note: [\s\S]*? is non-greedy but can still produce over-spanning matches
-    // in texts with many braces. This is acceptable as we try-parse each candidate
-    // and move to the next on failure. A bracket-balancing parser would be more
-    // precise but significantly more complex for marginal benefit.
-    const candidateRegex = /(\{[\s\S]*?\}|\[[\s\S]*?\])/g;
-    let candidate;
-    while ((candidate = candidateRegex.exec(text)) !== null) {
+    // Scan for balanced JSON object/array spans (quote/escape aware) and return
+    // the first one that parses. Unlike a non-greedy regex, this never stops at a
+    // "}" that lives inside a string value, so nested objects are preserved.
+    let searchFrom = 0;
+    for (;;) {
+        const found = nextBalancedJsonSpan(text, searchFrom);
+        if (!found) {
+            break;
+        }
         try {
-            JSON.parse(candidate[1]);
-            return candidate[1];
+            JSON.parse(found.span);
+            return found.span;
         }
         catch {
-            // Try next candidate
+            // Not valid JSON — resume scanning just past this opening character so a
+            // valid inner object/array can still be found.
         }
+        searchFrom = found.end - found.span.length + 1;
     }
     return null;
 }

package/dist/utils/modelDetection.d.ts

@@ -18,3 +18,20 @@ export declare function hasRestrictedOutputLimit(modelName: string): boolean;
  * Get the max output tokens for a model (32768 for restricted models)
  */
 export declare const RESTRICTED_OUTPUT_TOKEN_LIMIT = 32768;
+/**
+ * Normalize an Anthropic-API-style Claude model ID to the Vertex publisher
+ * format.
+ *
+ * The Anthropic API dates models with a trailing dash segment
+ * ("claude-haiku-4-5-20251001") while Vertex publisher IDs separate the date
+ * with "@" ("claude-haiku-4-5@20251001"). Vertex rejects the dash form with a
+ * 404 (verified live against us-east5), so the native Vertex+Claude paths
+ * normalize before calling @anthropic-ai/vertex-sdk.
+ *
+ * Pass-through cases: IDs already in "@" form, bare aliases with no date
+ * ("claude-sonnet-4-6" — Vertex resolves these itself), and non-Claude models.
+ * Legacy v2-suffixed Vertex IDs ("claude-3-5-sonnet-v2@20241022") have no
+ * dash-date equivalent, so those legacy dash IDs stay out of scope: they 404
+ * today and still 404 after the transform — no regression either way.
+ */
+export declare function toVertexAnthropicModelId(modelName: string): string;

package/dist/utils/modelDetection.js

@@ -105,3 +105,26 @@ export function hasRestrictedOutputLimit(modelName) {
  * Get the max output tokens for a model (32768 for restricted models)
  */
 export const RESTRICTED_OUTPUT_TOKEN_LIMIT = 32768;
+/**
+ * Normalize an Anthropic-API-style Claude model ID to the Vertex publisher
+ * format.
+ *
+ * The Anthropic API dates models with a trailing dash segment
+ * ("claude-haiku-4-5-20251001") while Vertex publisher IDs separate the date
+ * with "@" ("claude-haiku-4-5@20251001"). Vertex rejects the dash form with a
+ * 404 (verified live against us-east5), so the native Vertex+Claude paths
+ * normalize before calling @anthropic-ai/vertex-sdk.
+ *
+ * Pass-through cases: IDs already in "@" form, bare aliases with no date
+ * ("claude-sonnet-4-6" — Vertex resolves these itself), and non-Claude models.
+ * Legacy v2-suffixed Vertex IDs ("claude-3-5-sonnet-v2@20241022") have no
+ * dash-date equivalent, so those legacy dash IDs stay out of scope: they 404
+ * today and still 404 after the transform — no regression either way.
+ */
+export function toVertexAnthropicModelId(modelName) {
+    if (!modelName.startsWith("claude-") || modelName.includes("@")) {
+        return modelName;
+    }
+    const dashDate = modelName.match(/^(claude-[a-z0-9-]+)-(\d{8})$/);
+    return dashDate ? `${dashDate[1]}@${dashDate[2]}` : modelName;
+}

package/dist/utils/tokenLimits.d.ts

@@ -7,6 +7,26 @@ import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
  * Get the safe maximum tokens for a provider and model
  */
 export declare function getSafeMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, requestedMaxTokens?: number): number | undefined;
+/**
+ * Maximum output tokens supported by a given Anthropic Claude model.
+ *
+ * The native Vertex+Claude and native Anthropic message paths send `max_tokens`
+ * straight to the Anthropic API, which returns 400 if the value exceeds the
+ * model's published output ceiling. (The AI-SDK path clamps automatically;
+ * these native paths do not.) This table lets those paths default to the
+ * model's real ceiling — 64K for Sonnet/Haiku 4.x, 32K for Opus 4.x — instead of
+ * the legacy 4096 that silently truncated large structured responses.
+ *
+ * Unknown identifiers fall back to a safe modern floor (8192).
+ */
+export declare function getClaudeMaxOutputTokens(model: string | undefined): number;
+/**
+ * Resolve the `max_tokens` to send on a native Anthropic/Claude request: honour
+ * the caller's value but clamp it to the model's published ceiling, and default
+ * to that ceiling when the caller did not specify one. Prevents both silent
+ * truncation (the legacy 4096 default) and 400s from over-large requests.
+ */
+export declare function resolveClaudeMaxTokens(model: string | undefined, requested?: number): number;
 /**
  * Validate if maxTokens is safe for a provider/model combination
  */

package/dist/utils/tokenLimits.js

@@ -76,6 +76,61 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     // Use the requested value if it's within limits
     return requestedMaxTokens;
 }
+/**
+ * Maximum output tokens supported by a given Anthropic Claude model.
+ *
+ * The native Vertex+Claude and native Anthropic message paths send `max_tokens`
+ * straight to the Anthropic API, which returns 400 if the value exceeds the
+ * model's published output ceiling. (The AI-SDK path clamps automatically;
+ * these native paths do not.) This table lets those paths default to the
+ * model's real ceiling — 64K for Sonnet/Haiku 4.x, 32K for Opus 4.x — instead of
+ * the legacy 4096 that silently truncated large structured responses.
+ *
+ * Unknown identifiers fall back to a safe modern floor (8192).
+ */
+export function getClaudeMaxOutputTokens(model) {
+    const m = (model ?? "").toLowerCase();
+    // Claude 4.x family: Opus 4.x = 32K, Sonnet/Haiku 4.x = 64K.
+    if (/opus[-_.]?4/.test(m)) {
+        return 32000;
+    }
+    if (/sonnet[-_.]?4/.test(m) || /haiku[-_.]?4/.test(m)) {
+        return 64000;
+    }
+    // Claude 3.7 Sonnet supports 64K output.
+    if (/3[-_.]?7[-_.]?sonnet/.test(m)) {
+        return 64000;
+    }
+    // Claude 3.5 Sonnet / Haiku → 8192.
+    if (/3[-_.]?5[-_.]?(sonnet|haiku)/.test(m)) {
+        return 8192;
+    }
+    // Claude 3 Opus / Sonnet / Haiku → 4096.
+    if (/claude-3-(opus|sonnet|haiku)/.test(m) || /3[-_.]?opus/.test(m)) {
+        return 4096;
+    }
+    // Bare family aliases (latest of a family) → assume the modern ceiling.
+    if (m.includes("opus")) {
+        return 32000;
+    }
+    if (m.includes("sonnet") || m.includes("haiku")) {
+        return 64000;
+    }
+    return 8192;
+}
+/**
+ * Resolve the `max_tokens` to send on a native Anthropic/Claude request: honour
+ * the caller's value but clamp it to the model's published ceiling, and default
+ * to that ceiling when the caller did not specify one. Prevents both silent
+ * truncation (the legacy 4096 default) and 400s from over-large requests.
+ */
+export function resolveClaudeMaxTokens(model, requested) {
+    const ceiling = getClaudeMaxOutputTokens(model);
+    if (requested !== undefined && requested !== null && requested > 0) {
+        return Math.min(requested, ceiling);
+    }
+    return ceiling;
+}
 /**
  * Validate if maxTokens is safe for a provider/model combination
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.70.0",
+  "version": "9.70.2",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {
@@ -108,6 +108,8 @@
     "test:dynamic": "npx tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "npx tsx test/continuous-test-suite-proxy.ts",
     "test:bugfixes": "npx tsx test/continuous-test-suite-bugfixes.ts",
+    "test:json": "npx tsx test/continuous-test-suite-json.ts",
+    "test:json-e2e": "npx tsx test/continuous-test-suite-json-e2e.ts",
     "test:workflow": "npx tsx test/continuous-test-suite-workflow.ts",
     "test:hitl": "npx tsx test/continuous-test-suite-hitl.ts",
     "test:tasks": "npx tsx test/continuous-test-suite-tasks.ts",
@@ -341,6 +343,7 @@
     "inquirer": "^13.3.0",
     "jose": "^6.1.3",
     "json-schema-to-zod": "^2.7.0",
+    "jsonrepair": "^3.14.0",
     "nanoid": "^5.1.5",
     "open": "^11.0.0",
     "ora": "^9.3.0",