@juspay/neurolink 9.70.6 → 9.71.0

package/dist/utils/json/coerce.js

@@ -49,6 +49,73 @@ function parseOrRepair(candidate) {
         return undefined;
     }
 }
+/** Bounds the recursive nested-string unwrap against pathological inputs. */
+const MAX_NESTED_UNWRAP_DEPTH = 6;
+/**
+ * Recursively replace any string-valued field whose content is itself a JSON
+ * object/array with the parsed value. Models sometimes double-encode a NESTED
+ * field — e.g. `{ "attachment": "{\"k\":1}" }` instead of
+ * `{ "attachment": { "k": 1 } }` — which fails schema validation even though the
+ * intended object is right there. (`coerceJsonToSchema` already unwraps a
+ * stringified TOP-LEVEL object; this handles the nested case.)
+ *
+ * A parsed string is NOT re-descended into: its own string fields (e.g. an
+ * attachment's `content`) are the model's intended values and must be left
+ * alone. Recursion only walks already-structural objects/arrays to find
+ * stringified fields anywhere in the tree. Returns a NEW value (never mutates
+ * the input) plus whether anything changed, so the caller can skip a redundant
+ * re-validation when nothing was unwrapped. Callers MUST re-validate the result
+ * against the schema — that gate is what keeps an over-eager unwrap (a field
+ * that should stay a string) from being accepted.
+ */
+function deepUnwrapJsonStrings(value, depth = 0) {
+    if (depth > MAX_NESTED_UNWRAP_DEPTH) {
+        return { value, changed: false };
+    }
+    if (typeof value === "string") {
+        const s = value.trim();
+        const looksJson = (s.startsWith("{") && s.endsWith("}")) ||
+            (s.startsWith("[") && s.endsWith("]"));
+        if (looksJson) {
+            try {
+                const parsed = JSON.parse(s);
+                if (parsed !== null && typeof parsed === "object") {
+                    // Parsed one stringified layer. Do NOT descend into `parsed` — its
+                    // own string fields are intended values, not double-encodings.
+                    return { value: parsed, changed: true };
+                }
+            }
+            catch {
+                // not JSON — leave the string as-is
+            }
+        }
+        return { value, changed: false };
+    }
+    if (Array.isArray(value)) {
+        let changed = false;
+        const out = value.map((item) => {
+            const r = deepUnwrapJsonStrings(item, depth + 1);
+            if (r.changed) {
+                changed = true;
+            }
+            return r.value;
+        });
+        return { value: changed ? out : value, changed };
+    }
+    if (value !== null && typeof value === "object") {
+        let changed = false;
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const r = deepUnwrapJsonStrings(v, depth + 1);
+            if (r.changed) {
+                changed = true;
+            }
+            out[k] = r.value;
+        }
+        return { value: changed ? out : value, changed };
+    }
+    return { value, changed: false };
+}
 /**
  * Try to produce canonical JSON from `text`. Returns null when no JSON object
  * could be recovered (caller should then keep the raw text).
@@ -147,6 +214,24 @@ export function coerceJsonToSchema(text, schema) {
         if (safeParseable.safeParse(outcome.value).success) {
             schemaValid.push(record);
         }
+        else {
+            // The model may have double-encoded a NESTED field as a JSON string
+            // (e.g. `{"attachment":"{...}"}` instead of `{"attachment":{...}}`),
+            // which fails validation even though the intended object is present.
+            // Unwrap stringified object/array fields and re-validate before giving
+            // up — the safeParse gate rejects any over-eager unwrap.
+            const unwrapped = deepUnwrapJsonStrings(outcome.value);
+            if (unwrapped.changed &&
+                unwrapped.value !== null &&
+                typeof unwrapped.value === "object" &&
+                safeParseable.safeParse(unwrapped.value).success) {
+                schemaValid.push({
+                    value: unwrapped.value,
+                    repaired: true,
+                    truncated: candidate.truncated,
+                });
+            }
+        }
     }
     // Among schema-valid candidates prefer the MOST COMPLETE one. With nullable
     // fields a lean object (e.g. `{summary, attachment: null}`) validates

package/dist/utils/mcpErrorText.d.ts

@@ -8,3 +8,19 @@
  * must happen here and propagate to all three surfaces.
  */
 export declare function extractMcpErrorText(raw: unknown): string;
+/**
+ * MCP tools signal failure by RETURNING `{ isError: true, ... }`, not throwing,
+ * so execute()'s try/catch never sees it. Returns a capped status message for
+ * failures (undefined for success) for the caller to set the span error level.
+ *
+ * Generic over input shape: accepts either a result object or a JSON-stringified
+ * envelope (different providers hand back different shapes), mirroring
+ * `extractMcpErrorText`. A non-JSON string has no `isError` field, so it is
+ * correctly treated as "not an error" (→ undefined).
+ *
+ * Layered on `extractMcpErrorText`: this adds the `isError === true` gate and
+ * the human-readable "MCP tool returned isError: …" prefix, while the shared
+ * helper owns the content parsing and the 500-char cap. When `isError` is set
+ * but no readable text is present, falls back to a generic message.
+ */
+export declare function extractMcpToolErrorMessage(result: unknown): string | undefined;

package/dist/utils/mcpErrorText.js

@@ -33,3 +33,39 @@ export function extractMcpErrorText(raw) {
         .map((c) => c.text);
     return texts.join(" ").substring(0, 500);
 }
+/**
+ * MCP tools signal failure by RETURNING `{ isError: true, ... }`, not throwing,
+ * so execute()'s try/catch never sees it. Returns a capped status message for
+ * failures (undefined for success) for the caller to set the span error level.
+ *
+ * Generic over input shape: accepts either a result object or a JSON-stringified
+ * envelope (different providers hand back different shapes), mirroring
+ * `extractMcpErrorText`. A non-JSON string has no `isError` field, so it is
+ * correctly treated as "not an error" (→ undefined).
+ *
+ * Layered on `extractMcpErrorText`: this adds the `isError === true` gate and
+ * the human-readable "MCP tool returned isError: …" prefix, while the shared
+ * helper owns the content parsing and the 500-char cap. When `isError` is set
+ * but no readable text is present, falls back to a generic message.
+ */
+export function extractMcpToolErrorMessage(result) {
+    let resultObj = result;
+    if (typeof resultObj === "string") {
+        try {
+            resultObj = JSON.parse(resultObj);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!resultObj || typeof resultObj !== "object") {
+        return undefined;
+    }
+    if (resultObj.isError !== true) {
+        return undefined;
+    }
+    const text = extractMcpErrorText(resultObj);
+    return text
+        ? `MCP tool returned isError: ${text}`
+        : "MCP tool returned isError: true";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.70.6",
+  "version": "9.71.0",
   "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": {
@@ -104,6 +104,7 @@
     "test:log-sanitize": "npx tsx test/continuous-test-suite-log-sanitize.ts",
     "test:sse-client": "npx tsx test/continuous-test-suite-sse-client.ts",
     "test:stream-span": "npx tsx test/continuous-test-suite-stream-span.ts",
+    "test:vertex-langfuse-spans": "npx tsx test/continuous-test-suite-vertex-langfuse-spans.ts",
     "test:credentials": "npx tsx test/continuous-test-suite-credentials.ts",
     "test:dynamic": "npx tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "npx tsx test/continuous-test-suite-proxy.ts",
@@ -418,7 +419,7 @@
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.29.8",
     "@eslint/js": "^10.0.1",
-    "@juspay/hippocampus": "^0.1.6",
+    "@juspay/hippocampus": ">=0.1.7",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/sdk-trace-base": "^2.6.0",
     "@opentelemetry/sdk-trace-node": "^2.6.0",