@juspay/neurolink 12.14.21 → 12.15.1

package/dist/cli/commands/auth.js

@@ -248,8 +248,12 @@ function formatQuotaColumns(quota) {
         return chalk.green(text);
     };
     return {
-        sessionText: colorize(sessionRemaining, `${sessionRemaining}% left`),
-        weeklyText: colorize(weeklyRemaining, `${weeklyRemaining}% left`),
+        sessionText: quota.sessionStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(sessionRemaining, `${sessionRemaining}% left`),
+        weeklyText: quota.weeklyStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(weeklyRemaining, `${weeklyRemaining}% left`),
         sessionReset: quota.sessionResetAt > 0
             ? chalk.gray(`resets ${formatTimeUntil(quota.sessionResetAt)}`)
             : "",

package/dist/cli/commands/proxy.d.ts

@@ -82,6 +82,10 @@ export declare function createProxyStartApp(params: {
     app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
     readiness: ProxyReadinessState;
 }>;
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export declare function registerProxySupervisorReload(activeWorkerPid: () => number | undefined): () => void;
 export declare const proxyStartCommand: CommandModule<object, ProxyStartArgs>;
 export declare function sanitizeProxyStatusTerminalErrorMessage(message: string): string;
 export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;

package/dist/cli/commands/proxy.js

@@ -1,4 +1,5 @@
 import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { registerCliShutdownOwner } from "../lifecycle.js";
 import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
@@ -60,6 +61,9 @@ const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/obse
  */
 const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
+// Allow the normal 30-second worker drain plus startup settlement, leaving
+// telemetry and scheduling headroom inside launchd's 45-second stop budget.
+const PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS = 35_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
@@ -2504,10 +2508,12 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
-            await flushProxyOtelLogs();
-            await shutdownProxyOtelLogs();
-            await flushOpenTelemetry();
-            await shutdownOpenTelemetry();
+            await withShutdownDeadline((async () => {
+                await flushProxyOtelLogs();
+                await shutdownProxyOtelLogs();
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+            })(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "telemetry shutdown");
         }
         catch {
             // non-fatal — proxy shutdown must not block on OTel
@@ -2535,12 +2541,7 @@ function registerProxyShutdownHandlers(params) {
         process.exit(1);
     };
     if (params.registerSignals ?? true) {
-        process.on("SIGTERM", () => {
-            void shutdown("SIGTERM").catch(forceExitAfterShutdownFailure);
-        });
-        process.on("SIGINT", () => {
-            void shutdown("SIGINT").catch(forceExitAfterShutdownFailure);
-        });
+        registerCliShutdownOwner((signal) => shutdown(signal).catch(forceExitAfterShutdownFailure));
     }
     return shutdown;
 }
@@ -2866,10 +2867,81 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    let stopping = false;
+    let activeWorkerPid;
+    let rollingServerTask;
+    let restartControlTask;
+    let updaterSupervisor;
+    let activatePendingUpdate;
+    let otelInitialized = false;
+    /** Own startup as well as serving: await resources already being created,
+     * then drain each independently so one cleanup failure cannot skip the rest. */
+    const shutdown = async (signal) => {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        logger.always(`[proxy-supervisor] shutting down (${signal})`);
+        if (activatePendingUpdate) {
+            process.off("SIGUSR2", activatePendingUpdate);
+        }
+        let exitCode = process.exitCode ?? 0;
+        const reportCleanupFailure = (error) => {
+            exitCode = 1;
+            logger.warn(`[proxy-supervisor] cleanup failed: ${String(error)}`);
+        };
+        const cleanup = async (operation, timeoutMs = PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, timeoutMessage = "supervisor resource shutdown deadline exceeded") => {
+            try {
+                await withTimeout(Promise.resolve().then(operation), timeoutMs, timeoutMessage);
+            }
+            catch (error) {
+                reportCleanupFailure(error);
+            }
+        };
+        // Close independently: a stalled control must not delay the worker drain.
+        // The operations retain their continuations after a deadline, so a resource
+        // returned during telemetry cleanup is still closed without extending exit.
+        await Promise.all([
+            cleanup(async () => {
+                // Setup errors are already reported by the control-plane startup path.
+                const control = await restartControlTask?.catch(() => undefined);
+                await control?.close();
+            }),
+            cleanup(() => updaterSupervisor?.stop()),
+            cleanup(async () => {
+                const server = await rollingServerTask;
+                await server?.close();
+            }, PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS),
+        ]);
+        if (otelInitialized) {
+            await cleanup(async () => {
+                await flushProxyLifecycleEvents().catch(reportCleanupFailure);
+                await flushProxyOtelLogs().catch(reportCleanupFailure);
+                await shutdownProxyOtelLogs();
+            }, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "supervisor telemetry shutdown deadline exceeded");
+        }
+        await cleanup(() => {
+            const supervisorState = loadProxySupervisorState();
+            if (supervisorState?.pid === process.pid) {
+                clearProxySupervisorState();
+            }
+        });
+        process.exit(exitCode);
+    };
+    registerCliShutdownOwner(shutdown);
+    // Protect every startup await; a worker loads fresh config before readiness.
+    registerProxySupervisorReload(() => stopping ? undefined : activeWorkerPid?.());
     await loadProxyStartEnv(argv, spinner);
+    if (stopping) {
+        return;
+    }
     initializeProxyOtelLogs("supervisor");
+    otelInitialized = true;
     routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
+    if (stopping) {
+        return;
+    }
     const entryScript = process.argv[1];
     if (!entryScript) {
         throw new Error("proxy supervisor cannot resolve the CLI entry script");
@@ -2885,7 +2957,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     });
     let currentUpdaterPid;
     let restartControl;
-    const rollingServer = await startRollingProxyServer({
+    rollingServerTask = startRollingProxyServer({
         onEvent: (event) => logProxyLifecycleEvent({
             event: "supervisor_event",
             requestId: "-",
@@ -2920,9 +2992,20 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         },
         log: (message) => logger.always(message),
     });
+    // Retain the creation promise before awaiting it so shutdown owns late results.
+    const rollingServer = await rollingServerTask.catch((error) => {
+        if (!stopping) {
+            throw error;
+        }
+        return undefined;
+    });
+    if (stopping || !rollingServer) {
+        return;
+    }
+    activeWorkerPid = () => rollingServer.snapshot().active?.pid;
     let rollingReplacement = null;
-    const activatePendingUpdate = () => {
-        if (rollingReplacement) {
+    activatePendingUpdate = () => {
+        if (stopping || rollingReplacement) {
             return;
         }
         let pendingVersion;
@@ -2953,7 +3036,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     process.on("SIGUSR2", activatePendingUpdate);
     const readinessHost = host === "0.0.0.0" ? "127.0.0.1" : host;
     try {
-        restartControl = await startProxyRestartControl({
+        restartControlTask = startProxyRestartControl({
             stateDir: join(homedir(), ".neurolink"),
             server: rollingServer,
             getTelemetry: getProxyProcessTelemetry,
@@ -2977,11 +3060,15 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 return response.json();
             },
         });
+        restartControl = await restartControlTask;
     }
     catch (error) {
         // A control-plane setup failure must not stop an otherwise serving proxy.
         logger.warn(`[proxy-supervisor] safe restart control unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (stopping) {
+        return;
+    }
     const updatePersistedUpdaterPid = (updaterPid) => {
         currentUpdaterPid = updaterPid;
         const state = loadProxySupervisorState();
@@ -2994,7 +3081,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
             restartControl: restartControl?.identity,
         });
     };
-    const updaterSupervisor = startUpdaterWorkerSupervisor({
+    updaterSupervisor = startUpdaterWorkerSupervisor({
         spawnWorker: () => spawnProxyUpdater(readinessHost, rollingServer.address.port, process.pid, true),
         isProcessRunning,
         stopWorker: (pid) => process.kill(pid, "SIGTERM"),
@@ -3006,34 +3093,27 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         spinner.succeed(chalk.green("Claude proxy supervisor started successfully"));
     }
     logger.always(`[proxy-supervisor] listening on ${host}:${rollingServer.address.port} workerPid=${rollingServer.snapshot().active?.pid ?? "unknown"} version=${PROXY_VERSION}`);
-    let stopping = false;
-    /** Drain the rolling workers and flush the supervisor journal before clearing ownership. */
-    const shutdown = async (signal) => {
-        if (stopping) {
+    await new Promise(() => undefined);
+}
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export function registerProxySupervisorReload(activeWorkerPid) {
+    const reload = () => {
+        const pid = activeWorkerPid();
+        if (!pid) {
             return;
         }
-        stopping = true;
-        logger.always(`[proxy-supervisor] shutting down (${signal})`);
-        process.off("SIGUSR2", activatePendingUpdate);
-        await restartControl?.close();
-        updaterSupervisor.stop();
-        await rollingServer.close();
-        await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
-        await flushProxyOtelLogs().catch(() => undefined);
-        await shutdownProxyOtelLogs().catch(() => undefined);
-        const supervisorState = loadProxySupervisorState();
-        if (supervisorState?.pid === process.pid) {
-            clearProxySupervisorState();
+        try {
+            process.kill(pid, "SIGHUP");
+            logger.always(`[proxy-supervisor] forwarded configuration reload to worker pid=${pid}`);
+        }
+        catch (error) {
+            logger.warn(`[proxy-supervisor] configuration reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        process.exit(0);
     };
-    process.once("SIGTERM", () => {
-        void shutdown("SIGTERM");
-    });
-    process.once("SIGINT", () => {
-        void shutdown("SIGINT");
-    });
-    await new Promise(() => undefined);
+    process.on("SIGHUP", reload);
+    return () => process.off("SIGHUP", reload);
 }
 async function startProxyCommandHandler(argv) {
     const spinner = argv.quiet ? null : ora("Starting Claude proxy...").start();

package/dist/cli/index.js

@@ -9,6 +9,7 @@ process.env.DOTENV_CONFIG_QUIET = "true";
  */
 import { initializeCliParser } from "./parser.js";
 import chalk from "chalk";
+import { initializeCliLifecycle, cleanupCliLifecycle } from "./lifecycle.js";
 // Clean up pnpm-specific environment variables that cause npm warnings
 // These variables are set by pnpm but cause "Unknown env config" warnings in npm
 if (process.env.npm_config_verify_deps_before_run) {
@@ -30,34 +31,23 @@ catch {
 }
 // Enhanced CLI with Professional UX
 const cli = initializeCliParser();
+initializeCliLifecycle(async () => {
+    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
+    await flushOpenTelemetry();
+});
 // Execute CLI
 (async () => {
     try {
         // Parse and execute commands
         await cli.parse();
-        await cleanup();
+        await cleanupCliLifecycle();
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
         process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
-        await cleanup();
+        process.exitCode = 1;
+        await cleanupCliLifecycle();
         process.exit(1);
     }
 })();
-// Cleanup on exit
-process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("beforeExit", async () => {
-    await cleanup();
-});
-async function cleanup() {
-    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
-    await flushOpenTelemetry();
-}
 //# sourceMappingURL=index.js.map

package/dist/cli/lifecycle.d.ts

@@ -0,0 +1,8 @@
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export declare function initializeCliLifecycle(cleanup: () => Promise<void>, timeoutMs?: number): void;
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export declare function registerCliShutdownOwner(handler: (signal: NodeJS.Signals) => Promise<void>): void;
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export declare function cleanupCliLifecycle(): Promise<void>;
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export declare function runBoundedCliCleanup(cleanup: () => Promise<unknown>, timeoutMs?: number, onTimeout?: () => void): Promise<void>;

package/dist/cli/lifecycle.js

@@ -0,0 +1,90 @@
+/** One signal owner per CLI process. Proxy lifecycles own their drain and exit;
+ * ordinary commands only need a bounded, best-effort telemetry flush. */
+let owner;
+let cleanupTask;
+let cleanupPromise;
+let shutdownPromise;
+let installed = false;
+let cleanupTimeoutMs = 5_000;
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export function initializeCliLifecycle(cleanup, timeoutMs = 5_000) {
+    cleanupTask = cleanup;
+    cleanupTimeoutMs = timeoutMs;
+    installSignals();
+}
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export function registerCliShutdownOwner(handler) {
+    owner = handler;
+    installSignals();
+}
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export function cleanupCliLifecycle() {
+    if (owner) {
+        return Promise.resolve();
+    }
+    cleanupPromise ??= runBoundedCliCleanup(() => cleanupTask?.() ?? Promise.resolve(), cleanupTimeoutMs, () => {
+        // A stalled exporter may retain handles after Promise.race settles.
+        // A newly registered owner still retains control of draining and exit.
+        if (!owner) {
+            process.exit(process.exitCode ?? 0);
+        }
+    });
+    return cleanupPromise;
+}
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export async function runBoundedCliCleanup(cleanup, timeoutMs = 5_000, onTimeout) {
+    let timer;
+    let timedOut = false;
+    try {
+        await Promise.race([
+            Promise.resolve().then(cleanup),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error("telemetry flush deadline exceeded"));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        process.stderr.write(`[cli] cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (timedOut) {
+        onTimeout?.();
+    }
+}
+/** Install one process-wide signal dispatcher and reuse the first shutdown promise. */
+function installSignals() {
+    if (installed) {
+        return;
+    }
+    installed = true;
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            shutdownPromise ??= Promise.resolve()
+                .then(async () => {
+                if (!owner) {
+                    await cleanupCliLifecycle();
+                }
+                // Startup may register the proxy owner while the flush is pending.
+                if (owner) {
+                    await owner(signal);
+                }
+                else {
+                    process.exit(process.exitCode ?? 0);
+                }
+            })
+                .catch((error) => {
+                process.stderr.write(`[cli] shutdown failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.exit(1);
+            });
+        });
+    }
+    process.once("beforeExit", () => {
+        void cleanupCliLifecycle();
+    });
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/core/baseProvider.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema } from "../types/index.js";
+import type { UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema, EmbedInput } from "../types/index.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
 import type { LanguageModel, ModelMessage, RawUsageObject, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
 export declare abstract class BaseProvider implements AIProvider {
@@ -320,7 +320,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * Providers that support embeddings (OpenAI, Google Vertex, Amazon Bedrock)
      * should override this method with their specific implementation.
      *
-     * @param text - The text to embed
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param _modelName - Optional embedding model name (provider-specific)
      * @returns Promise resolving to the embedding vector (array of numbers)
      * @throws Error if the provider does not support embeddings
@@ -330,9 +330,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * const provider = await ProviderFactory.createProvider('openai', 'text-embedding-3-small');
      * const embedding = await provider.embed('Hello world');
      * console.log(embedding); // [0.123, -0.456, ...]
+     *
+     * // Multi-modal embedding (Bedrock Titan Image / Nova)
+     * const multiEmbedding = await provider.embed({ text: "a photo", image: imageBuffer, mimeType: "image/png" });
      * ```
      */
-    embed(text: string, _modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, _modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      *

package/dist/core/baseProvider.js

@@ -1772,7 +1772,7 @@ export class BaseProvider {
      * Providers that support embeddings (OpenAI, Google Vertex, Amazon Bedrock)
      * should override this method with their specific implementation.
      *
-     * @param text - The text to embed
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param _modelName - Optional embedding model name (provider-specific)
      * @returns Promise resolving to the embedding vector (array of numbers)
      * @throws Error if the provider does not support embeddings
@@ -1782,11 +1782,15 @@ export class BaseProvider {
      * const provider = await ProviderFactory.createProvider('openai', 'text-embedding-3-small');
      * const embedding = await provider.embed('Hello world');
      * console.log(embedding); // [0.123, -0.456, ...]
+     *
+     * // Multi-modal embedding (Bedrock Titan Image / Nova)
+     * const multiEmbedding = await provider.embed({ text: "a photo", image: imageBuffer, mimeType: "image/png" });
      * ```
      */
-    async embed(text, _modelName) {
+    async embed(input, _modelName) {
+        const textLength = typeof input === "string" ? input.length : (input.text?.length ?? 0);
         logger.warn(`embed() called on ${this.providerName} which does not have a native implementation`, {
-            textLength: text.length,
+            textLength,
         });
         throw new Error(`Embedding generation is not supported by the ${this.providerName} provider. ` +
             `Supported providers: openai, vertex/google, bedrock, cohere, voyage, jina. ` +

package/dist/providers/amazonBedrock/client.d.ts

@@ -2,7 +2,7 @@ import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 import type { AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import type { NeuroLink } from "../../neurolink.js";
-import type { StreamOptions, StreamResult, EnhancedGenerateResult, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, StreamOptions, StreamResult, EnhancedGenerateResult, TextGenerationOptions } from "../../types/index.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;
     private conversationHistory;
@@ -76,13 +76,15 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     checkBedrockHealth(): Promise<void>;
     protected formatProviderError(error: unknown): Error;
     /**
-     * Generate embeddings for text using Amazon Bedrock embedding models
-     * Uses the native AWS SDK InvokeModel command for Titan embeddings
-     * @param text - The text to embed
+     * Generate embeddings for text or multi-modal input using Amazon Bedrock.
+     * Supports both text-only models (Titan Embed Text) and multi-modal models
+     * (Titan Embed Image, Nova Multimodal Embeddings).
+     *
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      * @param texts - The texts to embed