@juspay/neurolink 9.50.2 → 9.51.1

package/dist/cli/commands/proxy.js

@@ -26,7 +26,14 @@ const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/obse
 // =============================================================================
 // STATE MANAGEMENT
 // =============================================================================
-const proxyStateManager = new StateFileManager("proxy-state.json");
+let proxyStateManager = new StateFileManager("proxy-state.json");
+/**
+ * Reinitialise the state manager with a custom base directory.
+ * Called when --dev redirects writable paths to .neurolink-dev/.
+ */
+function setProxyStateDir(baseDir) {
+    proxyStateManager = new StateFileManager("proxy-state.json", baseDir);
+}
 function saveProxyState(state) {
     proxyStateManager.save(state);
 }
@@ -333,12 +340,12 @@ async function loadProxyStartEnv(argv, spinner) {
         process.exit(1);
     }
 }
-async function createProxyNeurolinkRuntime() {
+async function createProxyNeurolinkRuntime(logsDir) {
     process.env.NEUROLINK_SKIP_MCP = "true";
     const { NeuroLink } = await import("../../lib/neurolink.js");
     const neurolink = new NeuroLink();
     const { initRequestLogger, cleanupLogs } = await import("../../lib/proxy/requestLogger.js");
-    initRequestLogger(true);
+    initRequestLogger(true, logsDir);
     cleanupLogs(7, 500);
     return { neurolink, cleanupLogs };
 }
@@ -701,7 +708,7 @@ function registerProxyShutdownHandlers(params) {
         catch {
             // non-fatal — proxy shutdown must not block on OTel
         }
-        if (signal === "SIGINT") {
+        if (signal === "SIGINT" && !params.isDev) {
             try {
                 const shutdownHost = params.host === "0.0.0.0" ? "localhost" : params.host;
                 await clearClaudeProxySettings(`http://${shutdownHost}:${params.port}`);
@@ -733,7 +740,11 @@ async function startProxyRuntime(params) {
         port: params.port,
         hostname: params.host,
     });
-    const guardPid = spawnFailOpenGuard(params.host, params.port, process.pid);
+    // Skip the fail-open guard in dev mode — it monitors the proxy and clears
+    // global Claude settings on exit, which is exactly what we want to avoid.
+    const guardPid = params.argv.dev
+        ? undefined
+        : spawnFailOpenGuard(params.host, params.port, process.pid);
     const readinessHost = params.host === "0.0.0.0" ? "127.0.0.1" : params.host;
     await waitForProxyReadiness({
         host: readinessHost,
@@ -767,10 +778,16 @@ async function startProxyRuntime(params) {
     if (params.spinner) {
         params.spinner.succeed(chalk.green("Claude proxy started successfully"));
     }
+    const isDev = params.argv.dev ?? false;
     const normalizedHost = params.host === "0.0.0.0" ? "localhost" : params.host;
     const url = `http://${normalizedHost}:${params.port}`;
     printProxyBanner(url, params.strategy);
-    logger.always(`  ${chalk.bold("Mode:")}       ${chalk.cyan(params.passthrough ? "passthrough" : "full")}`);
+    if (isDev) {
+        logger.always(`  ${chalk.bold("Mode:")}       ${chalk.magenta("dev (isolated — state in .neurolink-dev/)")}`);
+    }
+    else {
+        logger.always(`  ${chalk.bold("Mode:")}       ${chalk.cyan(params.passthrough ? "passthrough" : "full")}`);
+    }
     if (params.passthrough) {
         logger.always(chalk.yellow("  ! Passthrough mode forwards client auth directly to Anthropic"));
         logger.always(chalk.dim("    Stored proxy OAuth/API credentials are ignored; clients need their own valid Anthropic auth."));
@@ -778,29 +795,52 @@ async function startProxyRuntime(params) {
     if (params.loadedEnvFile) {
         logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(params.loadedEnvFile)}`);
     }
-    try {
-        await setClaudeProxySettings(url);
-        logger.always(chalk.green("  ✓ Auto-configured Claude Code settings"));
-        logger.always(chalk.dim("    Restart Claude Code to connect through proxy"));
+    if (!isDev) {
+        try {
+            await setClaudeProxySettings(url);
+            logger.always(chalk.green("  ✓ Auto-configured Claude Code settings"));
+            logger.always(chalk.dim("    Restart Claude Code to connect through proxy"));
+        }
+        catch (error) {
+            logger.debug("[proxy] Failed to auto-configure Claude Code: " +
+                (error instanceof Error ? error.message : String(error)));
+        }
     }
-    catch (error) {
-        logger.debug("[proxy] Failed to auto-configure Claude Code: " +
-            (error instanceof Error ? error.message : String(error)));
+    else {
+        logger.always(chalk.dim("  ⊘ Dev mode: skipping client auto-configuration"));
     }
     const maintenance = startProxyBackgroundMaintenance(params.cleanupLogs);
     registerProxyShutdownHandlers({
         server,
         host: params.host,
         port: params.port,
+        isDev,
         ...maintenance,
     });
 }
 async function startProxyCommandHandler(argv) {
     const spinner = argv.quiet ? null : ora("Starting Claude proxy...").start();
+    const isDev = argv.dev ?? false;
     try {
-        await ensureProxyStartAllowed(spinner);
+        // In dev mode: redirect writable state to .neurolink-dev/ and skip singleton check
+        let devPaths;
+        if (isDev) {
+            const { resolveProxyPaths } = await import("../../lib/proxy/proxyPaths.js");
+            devPaths = resolveProxyPaths(true);
+            setProxyStateDir(devPaths.stateDir);
+            const { initAccountQuota } = await import("../../lib/proxy/accountQuota.js");
+            initAccountQuota(devPaths.quotaFile);
+            // Ensure the dev state directory exists
+            const { mkdirSync, existsSync } = await import("fs");
+            if (!existsSync(devPaths.stateDir)) {
+                mkdirSync(devPaths.stateDir, { recursive: true, mode: 0o700 });
+            }
+        }
+        if (!isDev) {
+            await ensureProxyStartAllowed(spinner);
+        }
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
-        const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime();
+        const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
         const { proxyConfig, strategy, modelRouter, passthrough } = await loadProxyStartConfiguration(argv, spinner);
         if (spinner) {
             spinner.text = "Configuring server...";
@@ -904,6 +944,11 @@ export const proxyStartCommand = {
             type: "boolean",
             default: false,
             description: "Run in transparent passthrough mode (no retry, no rotation, no polyfill)",
+        })
+            .option("dev", {
+            type: "boolean",
+            default: false,
+            description: "Run in isolated dev mode — state files scoped to .neurolink-dev/ in cwd, no client auto-configuration, no singleton check",
         })
             .example("neurolink proxy start", "Start proxy on default port 55669 with fill-first strategy")
             .example("neurolink proxy start -p 8080 -s fill-first", "Start proxy on port 8080 with fill-first")

package/dist/cli/utils/serverUtils.d.ts

@@ -44,8 +44,9 @@ export declare class StateFileManager<T> {
     /**
      * Create a new state file manager
      * @param filename - Name of the state file (e.g., "serve-state.json")
+     * @param baseDir - Optional base directory (defaults to ~/.neurolink)
      */
-    constructor(filename: string);
+    constructor(filename: string, baseDir?: string);
     /**
      * Get the full path to the state file
      */

package/dist/cli/utils/serverUtils.js

@@ -92,9 +92,10 @@ export class StateFileManager {
     /**
      * Create a new state file manager
      * @param filename - Name of the state file (e.g., "serve-state.json")
+     * @param baseDir - Optional base directory (defaults to ~/.neurolink)
      */
-    constructor(filename) {
-        this.filePath = path.join(getNeuroLinkDir(), filename);
+    constructor(filename, baseDir) {
+        this.filePath = path.join(baseDir ?? getNeuroLinkDir(), filename);
     }
     /**
      * Get the full path to the state file
@@ -107,7 +108,10 @@ export class StateFileManager {
      * @param state - State object to save
      */
     save(state) {
-        ensureStateDir();
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
         fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2));
     }
     /**

package/dist/core/modules/Utilities.js

@@ -206,7 +206,11 @@ export class Utilities {
         if (result && typeof result === "object" && "success" in result) {
             const mcpResult = result;
             if (mcpResult.success) {
-                return mcpResult.data;
+                // If `data` field exists, return it (standard MCP format).
+                // Otherwise fall back to the full result object so the LLM
+                // receives the actual payload instead of `undefined`, which
+                // would cause it to re-call the tool in a loop.
+                return mcpResult.data !== undefined ? mcpResult.data : result;
             }
             else {
                 // Instead of throwing, return a structured error result

package/dist/lib/core/modules/Utilities.js

@@ -206,7 +206,11 @@ export class Utilities {
         if (result && typeof result === "object" && "success" in result) {
             const mcpResult = result;
             if (mcpResult.success) {
-                return mcpResult.data;
+                // If `data` field exists, return it (standard MCP format).
+                // Otherwise fall back to the full result object so the LLM
+                // receives the actual payload instead of `undefined`, which
+                // would cause it to re-call the tool in a loop.
+                return mcpResult.data !== undefined ? mcpResult.data : result;
             }
             else {
                 // Instead of throwing, return a structured error result

package/dist/lib/proxy/accountQuota.d.ts

@@ -16,6 +16,12 @@ import type { AccountQuota } from "../types/index.js";
  * Pure computation — no I/O, no blocking.
  */
 export declare function parseQuotaHeaders(headers: Headers | Record<string, string>): AccountQuota | null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export declare function initAccountQuota(quotaFilePath: string): void;
 /**
  * Load all persisted account quotas.
  * First call reads from disk; subsequent calls return the in-memory cache.

package/dist/lib/proxy/accountQuota.js

@@ -9,7 +9,7 @@
  * updates an in-memory cache and debounces disk writes so the request/response
  * path is never blocked by file I/O.
  */
-import { join } from "path";
+import { dirname, join } from "path";
 import { homedir } from "os";
 import { promises as fs } from "fs";
 // ---------------------------------------------------------------------------
@@ -73,11 +73,32 @@ let memoryCache = {};
 let cacheLoaded = false;
 let dirty = false;
 let flushTimer = null;
+/** Custom quota file path set via initAccountQuota(). */
+let customQuotaFilePath = null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export function initAccountQuota(quotaFilePath) {
+    customQuotaFilePath = quotaFilePath;
+    // Cancel any pending flush from a previous configuration so it does not
+    // write stale data to the new path.
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    // Reset cache so the new path is picked up on next load
+    memoryCache = {};
+    cacheLoaded = false;
+    dirty = false;
+}
 function getQuotaFilePath() {
-    return join(homedir(), ".neurolink", QUOTA_FILE);
+    return customQuotaFilePath ?? join(homedir(), ".neurolink", QUOTA_FILE);
 }
 async function ensureDir() {
-    const dir = join(homedir(), ".neurolink");
+    const filePath = getQuotaFilePath();
+    const dir = dirname(filePath);
     await fs.mkdir(dir, { recursive: true, mode: 0o700 }).catch(() => {
         // Non-fatal: directory may already exist
     });

package/dist/lib/proxy/proxyPaths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+export type ProxyPaths = {
+    /** Base directory for proxy state files */
+    stateDir: string;
+    /** logs/ — request/response logs */
+    logsDir: string;
+    /** account-quotas.json — per-account rate limit state */
+    quotaFile: string;
+    /** Whether this is a dev-mode isolated instance */
+    isDev: boolean;
+};
+export declare function resolveProxyPaths(dev: boolean): ProxyPaths;

package/dist/lib/proxy/proxyPaths.js

@@ -0,0 +1,35 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveProxyPaths(dev) {
+    if (dev) {
+        const base = join(process.cwd(), ".neurolink-dev");
+        return {
+            stateDir: base,
+            logsDir: join(base, "logs"),
+            quotaFile: join(base, "account-quotas.json"),
+            isDev: true,
+        };
+    }
+    const base = join(homedir(), ".neurolink");
+    return {
+        stateDir: base,
+        logsDir: join(base, "logs"),
+        quotaFile: join(base, "account-quotas.json"),
+        isDev: false,
+    };
+}
+//# sourceMappingURL=proxyPaths.js.map

package/dist/lib/proxy/requestLogger.d.ts

@@ -6,7 +6,7 @@
  * Useful for debugging and auditing proxy traffic.
  */
 import type { RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
-export declare function initRequestLogger(enabled?: boolean): void;
+export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**
  * Log an upstream attempt separately from the final request outcome.

package/dist/lib/proxy/requestLogger.js

@@ -44,13 +44,13 @@ const SENSITIVE_HEADER_NAMES = new Set([
 const SENSITIVE_HEADER_PATTERN = /token|secret|key|password|credential/i;
 /** JSON keys whose values should be redacted in request/response bodies. */
 const SENSITIVE_BODY_KEYS = /("(?:password|access_token|refresh_token|api_key|apiKey|secret|authorization|token|credential|x-api-key)"\s*:\s*)"(?:[^"\\]|\\.)*"/gi;
-export function initRequestLogger(enabled = true) {
+export function initRequestLogger(enabled = true, customLogsDir) {
     logEnabled = enabled;
     if (!enabled) {
         return;
     }
     try {
-        logDir = join(homedir(), ".neurolink", "logs");
+        logDir = customLogsDir ?? join(homedir(), ".neurolink", "logs");
         if (!existsSync(logDir)) {
             mkdirSync(logDir, { recursive: true, mode: 0o700 });
         }

package/dist/lib/types/cli.d.ts

@@ -765,6 +765,7 @@ export type ProxyStartArgs = {
     config?: string;
     envFile?: string;
     passthrough?: boolean;
+    dev?: boolean;
 };
 /** Arguments accepted by `neurolink proxy status` */
 export type ProxyStatusArgs = {

package/dist/lib/types/conversation.d.ts

@@ -385,7 +385,7 @@ export type AgenticLoopReportType = "META" | "GOOGLEADS" | "GOOGLEGA4" | "OTHER"
 /**
  * Status of an agentic loop report
  */
-export type AgenticLoopReportStatus = "INPROGRESS" | "COMPLETED";
+export type AgenticLoopReportStatus = "INPROGRESS" | "COMPLETED" | "CANCELLED" | "FAILED";
 /**
  * Metadata for an individual agentic loop report
  * A conversation session can have multiple reports tracked via this type
@@ -495,6 +495,8 @@ export type ConversationSummary = ConversationBase & {
 export type RedisStorageConfig = {
     /** Redis connection URL (e.g., 'rediss://host:6379' for TLS) */
     url?: string;
+    /** Redis username for ACL authentication (optional) */
+    username?: string;
     /** Redis host (default: 'localhost') */
     host?: string;
     /** Redis port (default: 6379) */

package/dist/lib/utils/messageBuilder.js

@@ -1209,6 +1209,155 @@ async function downloadImageFromUrl(url) {
         throw new Error(`Failed to download image from ${url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
+/**
+ * Get MIME type from file extension
+ */
+function getMimeTypeFromExtension(filePath) {
+    const ext = filePath.toLowerCase().split(".").pop();
+    switch (ext) {
+        case "png":
+            return "image/png";
+        case "gif":
+            return "image/gif";
+        case "webp":
+            return "image/webp";
+        case "bmp":
+            return "image/bmp";
+        case "tiff":
+        case "tif":
+            return "image/tiff";
+        default:
+            return "image/jpeg";
+    }
+}
+/**
+ * Detect MIME type from buffer magic bytes
+ * Returns undefined if format cannot be detected
+ */
+function detectMimeTypeFromBuffer(buffer) {
+    // JPEG: FF D8 FF
+    if (buffer.length >= 3 &&
+        buffer[0] === 0xff &&
+        buffer[1] === 0xd8 &&
+        buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (buffer.length >= 8 &&
+        buffer[0] === 0x89 &&
+        buffer[1] === 0x50 &&
+        buffer[2] === 0x4e &&
+        buffer[3] === 0x47 &&
+        buffer[4] === 0x0d &&
+        buffer[5] === 0x0a &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0x0a) {
+        return "image/png";
+    }
+    // GIF: 47 49 46 38 (37|39) 61
+    if (buffer.length >= 6 &&
+        buffer[0] === 0x47 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x38 &&
+        (buffer[4] === 0x37 || buffer[4] === 0x39) &&
+        buffer[5] === 0x61) {
+        return "image/gif";
+    }
+    // WebP: 52 49 46 46 ?? ?? ?? ?? 57 45 42 50
+    if (buffer.length >= 12 &&
+        buffer[0] === 0x52 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x46 &&
+        buffer[8] === 0x57 &&
+        buffer[9] === 0x45 &&
+        buffer[10] === 0x42 &&
+        buffer[11] === 0x50) {
+        return "image/webp";
+    }
+    // BMP: 42 4D
+    if (buffer.length >= 2 && buffer[0] === 0x42 && buffer[1] === 0x4d) {
+        return "image/bmp";
+    }
+    // TIFF: (49 49 2A 00) or (4D 4D 00 2A)
+    if (buffer.length >= 4 &&
+        ((buffer[0] === 0x49 &&
+            buffer[1] === 0x49 &&
+            buffer[2] === 0x2a &&
+            buffer[3] === 0x00) ||
+            (buffer[0] === 0x4d &&
+                buffer[1] === 0x4d &&
+                buffer[2] === 0x00 &&
+                buffer[3] === 0x2a))) {
+        return "image/tiff";
+    }
+    return undefined;
+}
+/**
+ * Convert file path to raw base64 string.
+ * Returns raw base64 (not a data: URI) to avoid SSRF validation in AI SDK v6.
+ */
+function convertFilePathToBase64(filePath) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Image file not found: ${filePath}`);
+    }
+    const buffer = readFileSync(filePath);
+    return buffer.toString("base64");
+}
+/**
+ * Process a single image input and convert to raw base64 format.
+ * IMPORTANT: Returns raw base64 (not a data: URI) to avoid SSRF validation
+ * in Vercel AI SDK v6. The SDK calls `new URL(image)` on string values;
+ * a data: URI is a valid URL, causing the SDK to "download" it and hit
+ * validateDownloadUrl which throws "URL scheme must be http or https, got data:".
+ * Passing raw base64 avoids this because `new URL(base64string)` throws and
+ * the SDK treats the string as inline base64 data instead.
+ */
+function processImageToBase64(image, index) {
+    let imageData;
+    let mimeType = "image/jpeg"; // Default mime type
+    if (typeof image === "string") {
+        if (image.startsWith("data:")) {
+            // Data URI (including downloaded URLs) - extract mime type and raw base64
+            const match = image.match(/^data:([^;]+);base64,(.+)$/);
+            if (match) {
+                mimeType = match[1];
+                imageData = match[2]; // Raw base64 only — NOT the full data: URI
+            }
+            else {
+                imageData = image;
+            }
+        }
+        else if (isInternetUrl(image)) {
+            // This should not happen as URLs are processed separately
+            throw new Error(`Unprocessed URL found in actualImages: ${image}`);
+        }
+        else {
+            // File path string - convert to raw base64
+            try {
+                imageData = convertFilePathToBase64(image);
+                mimeType = getMimeTypeFromExtension(image);
+            }
+            catch (error) {
+                MultimodalLogger.logError("FILE_PATH_CONVERSION", error, {
+                    index,
+                    filePath: image,
+                });
+                throw new Error(`Failed to convert file path to base64: ${image}. ${error}`, { cause: error });
+            }
+        }
+    }
+    else {
+        // Buffer - convert to raw base64 with proper MIME type detection
+        const detectedMimeType = detectMimeTypeFromBuffer(image);
+        if (detectedMimeType) {
+            mimeType = detectedMimeType;
+        }
+        imageData = image.toString("base64");
+    }
+    return { imageData, mimeType };
+}
 /**
  * Convert simple images format to Vercel AI SDK format with smart auto-detection
  * - URLs: Downloaded and converted to base64 for Vercel AI SDK compatibility
@@ -1270,80 +1419,8 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
     // Process all images (including downloaded URLs) for Vercel AI SDK
     actualImages.forEach(({ data: image }, index) => {
         try {
-            // Vercel AI SDK v6 expects { type: 'image', image: Buffer | string, mimeType?: string }
-            // IMPORTANT: The `image` field must be raw base64 or a Buffer — NOT a data: URI string.
-            // The AI SDK v6's download pipeline calls `new URL(image)` on string values. A data: URI
-            // is a valid URL, so the SDK tries to "download" it, which hits SSRF validation
-            // (validateDownloadUrl) and throws "URL scheme must be http or https, got data:".
-            // Passing raw base64 avoids this because `new URL(base64string)` throws and the SDK
-            // treats the string as inline base64 data instead.
-            let imageData;
-            let mimeType = "image/jpeg"; // Default mime type
-            if (typeof image === "string") {
-                if (image.startsWith("data:")) {
-                    // Data URI (including downloaded URLs) - extract mime type and raw base64
-                    const match = image.match(/^data:([^;]+);base64,(.+)$/);
-                    if (match) {
-                        mimeType = match[1];
-                        imageData = match[2]; // Raw base64 only — NOT the full data: URI
-                    }
-                    else {
-                        imageData = image;
-                    }
-                }
-                else if (isInternetUrl(image)) {
-                    // This should not happen as URLs are processed separately above
-                    // But handle it gracefully just in case
-                    throw new Error(`Unprocessed URL found in actualImages: ${image}`);
-                }
-                else {
-                    // File path string - convert to base64
-                    try {
-                        if (existsSync(image)) {
-                            const buffer = readFileSync(image);
-                            const base64 = buffer.toString("base64");
-                            // Detect mime type from file extension
-                            const ext = image.toLowerCase().split(".").pop();
-                            switch (ext) {
-                                case "png":
-                                    mimeType = "image/png";
-                                    break;
-                                case "gif":
-                                    mimeType = "image/gif";
-                                    break;
-                                case "webp":
-                                    mimeType = "image/webp";
-                                    break;
-                                case "bmp":
-                                    mimeType = "image/bmp";
-                                    break;
-                                case "tiff":
-                                case "tif":
-                                    mimeType = "image/tiff";
-                                    break;
-                                default:
-                                    mimeType = "image/jpeg";
-                                    break;
-                            }
-                            imageData = base64; // Raw base64 only
-                        }
-                        else {
-                            throw new Error(`Image file not found: ${image}`);
-                        }
-                    }
-                    catch (error) {
-                        MultimodalLogger.logError("FILE_PATH_CONVERSION", error, {
-                            index,
-                            filePath: image,
-                        });
-                        throw new Error(`Failed to convert file path to base64: ${image}. ${error}`, { cause: error });
-                    }
-                }
-            }
-            else {
-                // Buffer - convert to raw base64
-                imageData = image.toString("base64");
-            }
+            // Use helper function to process image and reduce nesting depth
+            const { imageData, mimeType } = processImageToBase64(image, index);
             content.push({
                 type: "image",
                 image: imageData,

package/dist/lib/utils/redis.js

@@ -353,6 +353,7 @@ export function getNormalizedConfig(config) {
     const defaultUserSessionsPrefix = keyPrefix.replace(/conversation:?$/, "user:sessions:");
     let host = config.host || "localhost";
     let port = config.port || 6379;
+    let username = config.username || "";
     let password = config.password || "";
     let db = config.db || 0;
     let url = config.url;
@@ -361,13 +362,14 @@ export function getNormalizedConfig(config) {
             const parsedUrl = new URL(url);
             host = parsedUrl.hostname;
             port = parsedUrl.port ? parseInt(parsedUrl.port) : 6379;
+            username = parsedUrl.username || username;
             password = parsedUrl.password || password;
             db = parsedUrl.pathname
                 ? parseInt(parsedUrl.pathname.replace("/", "")) || 0
                 : 0;
         }
         catch (e) {
-            const sanitizedUrl = url.replace(/:\/\/[^:]+:[^@]+@/, "://[redacted]@");
+            const sanitizedUrl = url.replace(/:\/\/[^@]+@/, "://[redacted]@");
             logger.warn("[redisUtils] Failed to parse Redis URL, falling back to component-based connection", {
                 url: sanitizedUrl,
                 error: e instanceof Error ? e.message : String(e),
@@ -380,6 +382,7 @@ export function getNormalizedConfig(config) {
         host,
         port,
         password,
+        username,
         db,
         keyPrefix,
         userSessionsKeyPrefix: config.userSessionsKeyPrefix || defaultUserSessionsPrefix,