@juspay/neurolink 9.1.1 → 9.2.0

package/dist/utils/json/extract.js

@@ -0,0 +1,248 @@
+/**
+ * JSON Extraction Utilities
+ *
+ * Utilities for extracting JSON from mixed text content.
+ * Particularly useful for parsing AI responses that contain JSON within prose.
+ */
+import { parseJsonOrNull } from "./safeParse.js";
+/**
+ * Extract JSON string from text that may contain surrounding content.
+ *
+ * Searches for valid JSON in the following order:
+ * 1. Direct parse of the entire text
+ * 2. JSON within markdown code blocks (```json ... ``` or ``` ... ```)
+ * 3. JSON object pattern ({ ... })
+ * 4. JSON array pattern ([ ... ])
+ *
+ * @param text - Text that may contain JSON
+ * @returns Extracted JSON string or null if none found
+ *
+ * @example
+ * ```typescript
+ * const response = "Here's the data: {\"name\": \"test\"} Let me know if you need more.";
+ * const json = extractJsonStringFromText(response);
+ * // Returns: '{"name": "test"}'
+ * ```
+ */
+export function extractJsonStringFromText(text) {
+    // Try direct parse first - maybe the whole text is valid JSON
+    try {
+        JSON.parse(text);
+        return text;
+    }
+    catch {
+        // Continue to extraction patterns
+    }
+    // Try to find JSON in code blocks (```json ... ``` or ``` ... ```)
+    const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+        const potentialJson = codeBlockMatch[1].trim();
+        try {
+            JSON.parse(potentialJson);
+            return potentialJson;
+        }
+        catch {
+            // 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) {
+        try {
+            JSON.parse(candidate[1]);
+            return candidate[1];
+        }
+        catch {
+            // Try next candidate
+        }
+    }
+    return null;
+}
+/**
+ * Extract and parse JSON from mixed text content.
+ *
+ * Useful for parsing AI responses that contain JSON within prose.
+ * Combines extraction and parsing in one step.
+ *
+ * @param text - Text that may contain JSON
+ * @returns Parsed JSON value or null if not found/invalid
+ *
+ * @example
+ * ```typescript
+ * const response = `
+ *   Here is your configuration:
+ *   \`\`\`json
+ *   {"theme": "dark", "fontSize": 14}
+ *   \`\`\`
+ *   Let me know if you need changes.
+ * `;
+ * const config = extractJsonFromText(response);
+ * // Returns: { theme: "dark", fontSize: 14 }
+ * ```
+ */
+export function extractJsonFromText(text) {
+    const jsonString = extractJsonStringFromText(text);
+    if (!jsonString) {
+        return null;
+    }
+    return parseJsonOrNull(jsonString);
+}
+/**
+ * Parse JSON from text with optional type validation.
+ *
+ * Extracts JSON from text and optionally validates it against a type guard.
+ * Useful when you need type-safe parsing of AI responses.
+ *
+ * @param text - Text that may contain JSON
+ * @param validator - Optional type guard to validate the parsed result
+ * @returns Parsed and validated JSON or null if not found/invalid/fails validation
+ *
+ * @example
+ * ```typescript
+ * interface UserConfig {
+ *   theme: string;
+ *   fontSize: number;
+ * }
+ *
+ * function isUserConfig(obj: unknown): obj is UserConfig {
+ *   return (
+ *     typeof obj === 'object' &&
+ *     obj !== null &&
+ *     'theme' in obj &&
+ *     'fontSize' in obj &&
+ *     typeof (obj as UserConfig).theme === 'string' &&
+ *     typeof (obj as UserConfig).fontSize === 'number'
+ *   );
+ * }
+ *
+ * const config = parseJsonFromText<UserConfig>(aiResponse, isUserConfig);
+ * if (config) {
+ *   // config is typed as UserConfig
+ *   console.log(config.theme, config.fontSize);
+ * }
+ * ```
+ */
+export function parseJsonFromText(text, validator) {
+    const parsed = extractJsonFromText(text);
+    if (parsed === null) {
+        return null;
+    }
+    if (validator && !validator(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+/**
+ * Extract all JSON objects/arrays from text.
+ *
+ * Useful when text contains multiple JSON blocks.
+ *
+ * @param text - Text that may contain multiple JSON values
+ * @returns Array of parsed JSON values
+ *
+ * @example
+ * ```typescript
+ * const text = 'First: {"a": 1} Second: {"b": 2}';
+ * const results = extractAllJsonFromText(text);
+ * // Returns: [{ a: 1 }, { b: 2 }]
+ * ```
+ */
+export function extractAllJsonFromText(text) {
+    const results = [];
+    // Extract from code blocks first
+    const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+    let match = codeBlockRegex.exec(text);
+    while (match !== null) {
+        if (match[1]) {
+            const potentialJson = match[1].trim();
+            try {
+                results.push(JSON.parse(potentialJson));
+            }
+            catch {
+                // Not valid JSON, skip
+            }
+        }
+        match = codeBlockRegex.exec(text);
+    }
+    // If we found code blocks, return those results
+    if (results.length > 0) {
+        return results;
+    }
+    // Otherwise, try to find all JSON objects and arrays
+    // This is a simplified approach - it finds top-level JSON structures
+    const remaining = text;
+    let searchStart = 0;
+    while (searchStart < remaining.length) {
+        // Find next potential JSON start
+        const objectStart = remaining.indexOf("{", searchStart);
+        const arrayStart = remaining.indexOf("[", searchStart);
+        let start;
+        let isObject;
+        if (objectStart === -1 && arrayStart === -1) {
+            break;
+        }
+        else if (objectStart === -1) {
+            start = arrayStart;
+            isObject = false;
+        }
+        else if (arrayStart === -1) {
+            start = objectStart;
+            isObject = true;
+        }
+        else {
+            start = Math.min(objectStart, arrayStart);
+            isObject = objectStart < arrayStart;
+        }
+        // Try to find matching end
+        const openChar = isObject ? "{" : "[";
+        const closeChar = isObject ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = start; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === "\\") {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (char === openChar) {
+                depth++;
+            }
+            else if (char === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    const potentialJson = remaining.substring(start, i + 1);
+                    try {
+                        results.push(JSON.parse(potentialJson));
+                        searchStart = i + 1;
+                    }
+                    catch {
+                        searchStart = start + 1;
+                    }
+                    break;
+                }
+            }
+        }
+        if (depth !== 0) {
+            // Unbalanced brackets, move past this start
+            searchStart = start + 1;
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * JSON Utilities
+ *
+ * Centralized JSON parsing, serialization, and extraction utilities.
+ * Provides safe operations that handle errors gracefully without throwing.
+ *
+ * @module json
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   safeParseJson,
+ *   parseJsonOrNull,
+ *   isValidJson,
+ *   safeStringify,
+ *   extractJsonFromText,
+ *   parseJsonFromText,
+ * } from './utils/json/index.js';
+ *
+ * // Safe parsing with fallback
+ * const config = safeParseJson(userInput, { theme: 'light' });
+ *
+ * // Check if valid before parsing
+ * if (isValidJson(str)) {
+ *   const data = JSON.parse(str);
+ * }
+ *
+ * // Handle circular references
+ * const json = safeStringify(complexObject, 2);
+ *
+ * // Extract JSON from AI responses
+ * const result = extractJsonFromText(aiResponse);
+ * ```
+ */
+export * from "./extract.js";
+export * from "./safeParse.js";

package/dist/utils/json/index.js

@@ -0,0 +1,36 @@
+/**
+ * JSON Utilities
+ *
+ * Centralized JSON parsing, serialization, and extraction utilities.
+ * Provides safe operations that handle errors gracefully without throwing.
+ *
+ * @module json
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   safeParseJson,
+ *   parseJsonOrNull,
+ *   isValidJson,
+ *   safeStringify,
+ *   extractJsonFromText,
+ *   parseJsonFromText,
+ * } from './utils/json/index.js';
+ *
+ * // Safe parsing with fallback
+ * const config = safeParseJson(userInput, { theme: 'light' });
+ *
+ * // Check if valid before parsing
+ * if (isValidJson(str)) {
+ *   const data = JSON.parse(str);
+ * }
+ *
+ * // Handle circular references
+ * const json = safeStringify(complexObject, 2);
+ *
+ * // Extract JSON from AI responses
+ * const result = extractJsonFromText(aiResponse);
+ * ```
+ */
+export * from "./extract.js";
+export * from "./safeParse.js";

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

@@ -0,0 +1,137 @@
+/**
+ * Safe JSON Parsing Utilities
+ *
+ * Centralized JSON parsing utilities that handle errors gracefully.
+ * Provides safe parsing that doesn't throw on invalid JSON.
+ */
+/**
+ * Result type for safe JSON parsing operations
+ */
+export interface SafeParseResult<T> {
+    success: boolean;
+    data: T | null;
+    error: Error | null;
+}
+/**
+ * Safely parse a JSON string without throwing.
+ *
+ * This is the preferred method for parsing JSON from external sources
+ * (user input, API responses, etc.) where invalid JSON is possible.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Object with success flag and either data or error
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseJsonResult<UserData>(userInput);
+ * if (result.success) {
+ *   console.log(result.data.name);
+ * } else {
+ *   console.error('Invalid JSON:', result.error.message);
+ * }
+ * ```
+ */
+export declare function safeParseJsonResult<T = unknown>(str: string): SafeParseResult<T>;
+/**
+ * Safely parse JSON with fallback value.
+ *
+ * Useful when you need a value regardless of parse success.
+ *
+ * @param str - The string to parse as JSON
+ * @param fallback - Value to return if parsing fails
+ * @returns Parsed value or fallback
+ *
+ * @example
+ * ```typescript
+ * const config = safeParseJson(configString, { theme: 'light' });
+ * // Always returns an object, never throws
+ * ```
+ */
+export declare function safeParseJson<T>(str: string, fallback: T): T;
+/**
+ * Parse JSON or return undefined if invalid.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Parsed value or undefined
+ *
+ * @example
+ * ```typescript
+ * const data = parseJsonOrUndefined<Config>(input);
+ * if (data) {
+ *   // Use data
+ * }
+ * ```
+ */
+export declare function parseJsonOrUndefined<T>(str: string): T | undefined;
+/**
+ * Parse JSON or return null if invalid.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Parsed value or null
+ *
+ * @example
+ * ```typescript
+ * const data = parseJsonOrNull<Config>(input);
+ * if (data !== null) {
+ *   // Use data
+ * }
+ * ```
+ */
+export declare function parseJsonOrNull<T>(str: string): T | null;
+/**
+ * Check if a string is valid JSON.
+ *
+ * @param str - The string to validate
+ * @returns true if the string is valid JSON
+ *
+ * @example
+ * ```typescript
+ * if (isValidJson(userInput)) {
+ *   // Proceed with parsing
+ * }
+ * ```
+ */
+export declare function isValidJson(str: string): boolean;
+/**
+ * Safe stringify with circular reference handling.
+ *
+ * Handles circular references, BigInt values, and other edge cases gracefully.
+ *
+ * @param obj - Value to stringify
+ * @param space - Optional indentation (number of spaces)
+ * @returns JSON string, with circular references replaced by "[Circular]"
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: 'test' };
+ * obj.self = obj; // Circular reference
+ *
+ * const json = safeStringify(obj);
+ * // Returns: '{"name":"test","self":"[Circular]"}'
+ *
+ * const prettyJson = safeStringify(data, 2);
+ * // Returns formatted JSON with 2-space indentation
+ * ```
+ */
+export declare function safeStringify(obj: unknown, space?: number): string;
+/**
+ * Safe stringify with options for more control.
+ *
+ * @param obj - Value to stringify
+ * @param options - Stringify options
+ * @returns JSON string or fallback string on error
+ *
+ * @example
+ * ```typescript
+ * const json = safeStringifyWithOptions(data, {
+ *   pretty: true,
+ *   fallback: '{}',
+ * });
+ * ```
+ */
+export declare function safeStringifyWithOptions(obj: unknown, options?: {
+    /** Use 2-space indentation */
+    pretty?: boolean;
+    /** Value to return if stringify fails */
+    fallback?: string;
+}): string;

package/dist/utils/json/safeParse.js

@@ -0,0 +1,190 @@
+/**
+ * Safe JSON Parsing Utilities
+ *
+ * Centralized JSON parsing utilities that handle errors gracefully.
+ * Provides safe parsing that doesn't throw on invalid JSON.
+ */
+/**
+ * Safely parse a JSON string without throwing.
+ *
+ * This is the preferred method for parsing JSON from external sources
+ * (user input, API responses, etc.) where invalid JSON is possible.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Object with success flag and either data or error
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseJsonResult<UserData>(userInput);
+ * if (result.success) {
+ *   console.log(result.data.name);
+ * } else {
+ *   console.error('Invalid JSON:', result.error.message);
+ * }
+ * ```
+ */
+export function safeParseJsonResult(str) {
+    try {
+        const data = JSON.parse(str);
+        return { success: true, data, error: null };
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: null,
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
+}
+/**
+ * Safely parse JSON with fallback value.
+ *
+ * Useful when you need a value regardless of parse success.
+ *
+ * @param str - The string to parse as JSON
+ * @param fallback - Value to return if parsing fails
+ * @returns Parsed value or fallback
+ *
+ * @example
+ * ```typescript
+ * const config = safeParseJson(configString, { theme: 'light' });
+ * // Always returns an object, never throws
+ * ```
+ */
+export function safeParseJson(str, fallback) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Parse JSON or return undefined if invalid.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Parsed value or undefined
+ *
+ * @example
+ * ```typescript
+ * const data = parseJsonOrUndefined<Config>(input);
+ * if (data) {
+ *   // Use data
+ * }
+ * ```
+ */
+export function parseJsonOrUndefined(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parse JSON or return null if invalid.
+ *
+ * @param str - The string to parse as JSON
+ * @returns Parsed value or null
+ *
+ * @example
+ * ```typescript
+ * const data = parseJsonOrNull<Config>(input);
+ * if (data !== null) {
+ *   // Use data
+ * }
+ * ```
+ */
+export function parseJsonOrNull(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a string is valid JSON.
+ *
+ * @param str - The string to validate
+ * @returns true if the string is valid JSON
+ *
+ * @example
+ * ```typescript
+ * if (isValidJson(userInput)) {
+ *   // Proceed with parsing
+ * }
+ * ```
+ */
+export function isValidJson(str) {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Safe stringify with circular reference handling.
+ *
+ * Handles circular references, BigInt values, and other edge cases gracefully.
+ *
+ * @param obj - Value to stringify
+ * @param space - Optional indentation (number of spaces)
+ * @returns JSON string, with circular references replaced by "[Circular]"
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: 'test' };
+ * obj.self = obj; // Circular reference
+ *
+ * const json = safeStringify(obj);
+ * // Returns: '{"name":"test","self":"[Circular]"}'
+ *
+ * const prettyJson = safeStringify(data, 2);
+ * // Returns formatted JSON with 2-space indentation
+ * ```
+ */
+export function safeStringify(obj, space) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (_key, value) => {
+        // Handle BigInt
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        // Handle circular references
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                return "[Circular]";
+            }
+            seen.add(value);
+        }
+        return value;
+    }, space);
+}
+/**
+ * Safe stringify with options for more control.
+ *
+ * @param obj - Value to stringify
+ * @param options - Stringify options
+ * @returns JSON string or fallback string on error
+ *
+ * @example
+ * ```typescript
+ * const json = safeStringifyWithOptions(data, {
+ *   pretty: true,
+ *   fallback: '{}',
+ * });
+ * ```
+ */
+export function safeStringifyWithOptions(obj, options) {
+    const { pretty = false, fallback = "[Unable to stringify]" } = options ?? {};
+    try {
+        const space = pretty ? 2 : undefined;
+        return safeStringify(obj, space);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/utils/messageBuilder.d.ts

@@ -3,11 +3,11 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
+import type { CoreMessage } from "ai";
 import type { MultimodalChatMessage } from "../types/conversation.js";
+import type { GenerateOptions } from "../types/generateTypes.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
-import type { GenerateOptions } from "../types/generateTypes.js";
-import type { CoreMessage } from "ai";
 /**
  * Type-safe conversion from MultimodalChatMessage[] to CoreMessage[]
  * Filters out invalid content and ensures strict CoreMessage contract compliance

package/dist/utils/messageBuilder.js

@@ -3,15 +3,15 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
+import { existsSync, readFileSync } from "fs";
+import { getGlobalDispatcher, interceptors, request } from "undici";
+import { MultimodalLogger, ProviderImageAdapter, } from "../adapters/providerImageAdapter.js";
 import { CONVERSATION_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS, } from "../config/conversationMemory.js";
-import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerImageAdapter.js";
-import { logger } from "./logger.js";
 import { FileDetector } from "./fileDetector.js";
-import { PDFProcessor, PDFImageConverter } from "./pdfProcessor.js";
-import { urlDownloadRateLimiter } from "./rateLimiter.js";
-import { request, getGlobalDispatcher, interceptors } from "undici";
 import { getImageCache } from "./imageCache.js";
-import { readFileSync, existsSync } from "fs";
+import { logger } from "./logger.js";
+import { PDFImageConverter, PDFProcessor } from "./pdfProcessor.js";
+import { urlDownloadRateLimiter } from "./rateLimiter.js";
 /**
  * Type guard to check if an image input has alt text
  */
@@ -376,7 +376,7 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
             try {
                 const result = await FileDetector.detectAndProcess(file, {
                     maxSize,
-                    allowedTypes: ["csv", "image", "pdf"],
+                    allowedTypes: ["csv", "image", "pdf", "svg"],
                     csvOptions: options.csvOptions,
                     provider: provider,
                 });
@@ -396,6 +396,14 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
                     options.input.text += csvSection;
                     logger.info(`[FileDetector] ✅ CSV: ${filename}`);
                 }
+                else if (result.type === "svg") {
+                    // SVG is processed as text content (sanitized XML markup)
+                    // Inject into text prompt instead of sending as image
+                    const filename = extractFilename(file);
+                    const svgSection = `\n\n## SVG Content from "${filename}":\n\`\`\`xml\n${result.content}\n\`\`\`\n`;
+                    options.input.text += svgSection;
+                    logger.info(`[FileDetector] ✅ SVG (as text): ${filename}`);
+                }
                 else if (result.type === "image") {
                     options.input.images = [
                         ...(options.input.images || []),