@juspay/neurolink 9.63.1 → 9.65.0

package/dist/lib/utils/tokenLimits.js

@@ -2,30 +2,14 @@
  * Provider-specific token limit utilities
  * Provides safe maxTokens values based on provider and model capabilities
  */
-import { PROVIDER_MAX_TOKENS, IMAGE_GENERATION_MODELS, } from "../core/constants.js";
+import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 import { logger } from "./logger.js";
-// Gemini 3 models and Gemini 2.5 image models have a hard limit of 32768 output tokens
-const GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS = 32768;
-/**
- * Check if a model has the restricted 32768 output token limit
- * This applies to:
- * - All Gemini 3 models (gemini-3-flash, gemini-3-pro, etc.)
- * - All Gemini 2.5 image generation models (gemini-2.5-flash-image)
- */
-function hasRestrictedOutputLimit(model) {
-    if (!model) {
-        return false;
-    }
-    // Check for Gemini 3 models
-    if (model.includes("gemini-3")) {
-        return true;
-    }
-    // Check for image generation models (includes gemini-2.5-flash-image)
-    if (IMAGE_GENERATION_MODELS.some((m) => model.includes(m))) {
-        return true;
-    }
-    return false;
-}
+import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "./modelDetection.js";
+// Restricted-model detection (Gemini 3.x + image-gen models capped at 32768
+// output tokens) lives in modelDetection.ts. Importing the canonical helper
+// keeps both call sites on one definition; the previous local copy used
+// case-sensitive substring matches and could miss identifiers like
+// "Gemini-3-Pro" which the canonical anchored, case-insensitive regex matches.
 /**
  * Get the safe maximum tokens for a provider and model
  */
@@ -33,19 +17,19 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     // CRITICAL: Gemini 3 models AND image generation models have a hard limit of 32768 output tokens
     // This check must happen FIRST, before any other logic, because these models
     // will reject requests with maxOutputTokens > 32768
-    const isRestrictedModel = hasRestrictedOutputLimit(model);
+    const isRestrictedModel = model ? hasRestrictedOutputLimit(model) : false;
     if (isRestrictedModel) {
         // Explicit undefined/null check so a caller-supplied 0 is preserved
-        // (truthy checks would treat 0 as "unset" and silently fall back to the cap).
+        // (truthy guards would treat 0 as "unset" and silently fall back to the cap).
         if (requestedMaxTokens !== undefined &&
             requestedMaxTokens !== null &&
-            requestedMaxTokens > GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS) {
-            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${model} limit of ${GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS}. Using ${GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS} instead.`);
-            return GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS;
+            requestedMaxTokens > RESTRICTED_OUTPUT_TOKEN_LIMIT) {
+            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${model} limit of ${RESTRICTED_OUTPUT_TOKEN_LIMIT}. Using ${RESTRICTED_OUTPUT_TOKEN_LIMIT} instead.`);
+            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
         }
         // If no maxTokens specified, use the restricted limit as default
         if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-            return GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS;
+            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
         }
         // Otherwise, use the requested value (it's within limits, including 0)
         return requestedMaxTokens;
@@ -54,7 +38,12 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     const providerLimits = PROVIDER_MAX_TOKENS[provider];
     if (!providerLimits) {
         logger.warn(`Unknown provider ${provider}, no token limits enforced`);
-        return requestedMaxTokens || undefined; // No default limit for unknown providers
+        // Explicit undefined/null check so a caller-supplied 0 is preserved
+        // (truthy guard would silently drop 0 here as it does in the restricted branch).
+        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
+            return undefined;
+        }
+        return requestedMaxTokens;
     }
     // Get model-specific limit or provider default
     let maxLimit;
@@ -73,8 +62,10 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     else {
         maxLimit = PROVIDER_MAX_TOKENS.default;
     }
-    // If no specific maxTokens requested, return the provider limit
-    if (!requestedMaxTokens) {
+    // If no specific maxTokens requested, return the provider limit.
+    // Use explicit undefined/null so a caller-supplied 0 is preserved
+    // (matches the restricted-model branch above).
+    if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
         return maxLimit;
     }
     // If requested maxTokens exceeds the limit, use the limit and warn

package/dist/lib/utils/videoProcessor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Video Generation Processing Utility
+ *
+ * Central registry + dispatch for video-generation handlers across
+ * providers (Vertex Veo, Kling, Runway, Replicate-hosted models, etc.).
+ *
+ * Mirrors the static-handler-registry pattern established by
+ * `TTSProcessor` (`utils/ttsProcessor.ts`) and `STTProcessor`
+ * (`utils/sttProcessor.ts`).
+ *
+ * @module utils/videoProcessor
+ */
+import { VIDEO_ERROR_CODES } from "../constants/videoErrors.js";
+import type { VideoGenerationResult, VideoHandler, VideoOutputOptions, VideoTransitionOptions } from "../types/index.js";
+import { VideoError } from "../adapters/video/vertexVideoHandler.js";
+export { VideoError, VIDEO_ERROR_CODES };
+/**
+ * Static processor managing the video handler registry.
+ *
+ * Handlers register themselves during `ProviderRegistry._doRegister()`
+ * via `VideoProcessor.registerHandler(name, instance)`. Lookups are
+ * O(1) on a normalised lower-case provider key.
+ */
+export declare class VideoProcessor {
+    private static readonly handlers;
+    /**
+     * Register a video handler for a specific provider.
+     */
+    static registerHandler(providerName: string, handler: VideoHandler): void;
+    /**
+     * Check if a provider has a registered video handler.
+     */
+    static supports(providerName: string): boolean;
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders(): string[];
+    private static getHandler;
+    private static buildSpanAttributes;
+    /**
+     * Generate a single video clip via the registered handler.
+     *
+     * @param provider - Registered provider name (e.g. "vertex", "kling")
+     * @param image - Source image buffer
+     * @param prompt - Text prompt describing the desired motion / content
+     * @param options - Resolution / length / aspect-ratio / audio options
+     * @param region - Optional region override (Vertex location, etc.)
+     * @throws VideoError on registry miss, handler-not-configured, or
+     *         generation failure
+     */
+    static generate(provider: string, image: Buffer, prompt: string, options: VideoOutputOptions, region?: string): Promise<VideoGenerationResult>;
+    /**
+     * Generate a transition clip via the registered handler (Director Mode).
+     *
+     * Providers without first-and-last-frame interpolation surface a typed
+     * `TRANSITION_NOT_SUPPORTED` error here; callers should fall back to
+     * generating a regular clip with a transition prompt.
+     */
+    static generateTransition(provider: string, firstFrame: Buffer, lastFrame: Buffer, prompt: string, options?: VideoTransitionOptions, region?: string): Promise<Buffer>;
+}

package/dist/lib/utils/videoProcessor.js

@@ -0,0 +1,201 @@
+/**
+ * Video Generation Processing Utility
+ *
+ * Central registry + dispatch for video-generation handlers across
+ * providers (Vertex Veo, Kling, Runway, Replicate-hosted models, etc.).
+ *
+ * Mirrors the static-handler-registry pattern established by
+ * `TTSProcessor` (`utils/ttsProcessor.ts`) and `STTProcessor`
+ * (`utils/sttProcessor.ts`).
+ *
+ * @module utils/videoProcessor
+ */
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
+import { VIDEO_ERROR_CODES } from "../constants/videoErrors.js";
+import { SpanSerializer, SpanStatus, SpanType, getMetricsAggregator, } from "../observability/index.js";
+import { logger } from "./logger.js";
+// VideoError is canonical in vertexVideoHandler.ts (existing). Re-export
+// here so consumers of `VideoProcessor` can import the typed error from
+// the same module. Both throws and instanceof checks resolve to the same
+// class.
+import { VideoError } from "../adapters/video/vertexVideoHandler.js";
+export { VideoError, VIDEO_ERROR_CODES };
+/**
+ * Static processor managing the video handler registry.
+ *
+ * Handlers register themselves during `ProviderRegistry._doRegister()`
+ * via `VideoProcessor.registerHandler(name, instance)`. Lookups are
+ * O(1) on a normalised lower-case provider key.
+ */
+export class VideoProcessor {
+    static handlers = new Map();
+    /**
+     * Register a video handler for a specific provider.
+     */
+    static registerHandler(providerName, handler) {
+        if (!providerName) {
+            throw new Error("Provider name is required");
+        }
+        if (!handler) {
+            throw new Error("Handler is required");
+        }
+        const key = providerName.toLowerCase();
+        if (this.handlers.has(key)) {
+            logger.warn(`[VideoProcessor] Overwriting existing handler for provider: ${key}`);
+        }
+        this.handlers.set(key, handler);
+        logger.debug(`[VideoProcessor] Registered video handler: ${key}`);
+    }
+    /**
+     * Check if a provider has a registered video handler.
+     */
+    static supports(providerName) {
+        if (!providerName) {
+            return false;
+        }
+        return this.handlers.has(providerName.toLowerCase());
+    }
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders() {
+        return Array.from(this.handlers.keys());
+    }
+    static getHandler(providerName) {
+        return this.handlers.get(providerName.toLowerCase());
+    }
+    static buildSpanAttributes(provider, options) {
+        return {
+            "video.operation": "generate",
+            "video.provider": provider,
+            "video.resolution": options.resolution,
+            "video.duration": options.length,
+            "video.aspect_ratio": options.aspectRatio,
+            "video.audio": options.audio,
+        };
+    }
+    /**
+     * Generate a single video clip via the registered handler.
+     *
+     * @param provider - Registered provider name (e.g. "vertex", "kling")
+     * @param image - Source image buffer
+     * @param prompt - Text prompt describing the desired motion / content
+     * @param options - Resolution / length / aspect-ratio / audio options
+     * @param region - Optional region override (Vertex location, etc.)
+     * @throws VideoError on registry miss, handler-not-configured, or
+     *         generation failure
+     */
+    static async generate(provider, image, prompt, options, region) {
+        const span = SpanSerializer.createSpan(SpanType.MEDIA_GENERATION, "video.generate", this.buildSpanAttributes(provider, options));
+        try {
+            const handler = this.getHandler(provider);
+            if (!handler) {
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.PROVIDER_NOT_SUPPORTED,
+                    message: `Video provider "${provider}" is not registered. Available: ${this.listProviders().join(", ")}`,
+                    category: ErrorCategory.CONFIGURATION,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: false,
+                    context: { provider, available: this.listProviders() },
+                });
+            }
+            if (!handler.isConfigured()) {
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                    message: `Video provider "${provider}" is not configured. Set the required credentials.`,
+                    category: ErrorCategory.CONFIGURATION,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: false,
+                    context: { provider },
+                });
+            }
+            logger.debug(`[VideoProcessor] Starting video generation with provider: ${provider}`);
+            const result = await handler.generate(image, prompt, options, region);
+            const ended = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(ended);
+            logger.info(`[VideoProcessor] Generated ${result.data.length} bytes (${provider})`);
+            return result;
+        }
+        catch (err) {
+            const ended = SpanSerializer.endSpan(span, SpanStatus.ERROR, err instanceof Error ? err.message : String(err));
+            getMetricsAggregator().recordSpan(ended);
+            if (err instanceof VideoError) {
+                throw err;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                message: `Video generation failed for provider "${provider}": ${message}`,
+                category: ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable: true,
+                context: { provider, options, region },
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+    /**
+     * Generate a transition clip via the registered handler (Director Mode).
+     *
+     * Providers without first-and-last-frame interpolation surface a typed
+     * `TRANSITION_NOT_SUPPORTED` error here; callers should fall back to
+     * generating a regular clip with a transition prompt.
+     */
+    static async generateTransition(provider, firstFrame, lastFrame, prompt, options, region) {
+        const handler = this.getHandler(provider);
+        if (!handler) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.PROVIDER_NOT_SUPPORTED,
+                message: `Video provider "${provider}" is not registered for transitions`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+                context: { provider, available: this.listProviders() },
+            });
+        }
+        if (!handler.generateTransition) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.TRANSITION_NOT_SUPPORTED,
+                message: `Video provider "${provider}" does not support transition clips`,
+                category: ErrorCategory.VALIDATION,
+                severity: ErrorSeverity.MEDIUM,
+                retriable: false,
+                context: { provider },
+            });
+        }
+        if (!handler.isConfigured()) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                message: `Video provider "${provider}" is not configured`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+                context: { provider },
+            });
+        }
+        try {
+            return await handler.generateTransition(firstFrame, lastFrame, prompt, options, region);
+        }
+        catch (err) {
+            if (err instanceof VideoError) {
+                throw err;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.DIRECTOR_TRANSITION_FAILED,
+                message: `Video transition generation failed for provider "${provider}": ${message}`,
+                category: ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.MEDIUM,
+                retriable: true,
+                context: {
+                    provider,
+                    firstFrameSize: firstFrame.length,
+                    lastFrameSize: lastFrame.length,
+                    durationSeconds: options?.durationSeconds,
+                },
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+}
+//# sourceMappingURL=videoProcessor.js.map

package/dist/lib/voice/providers/FishAudioTTS.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Fish Audio TTS Handler
+ *
+ * Implementation of TTS using Fish Audio API. Lower-cost alternative to
+ * ElevenLabs with strong multilingual support and 15s voice cloning.
+ *
+ * @module voice/providers/FishAudioTTS
+ * @see https://docs.fish.audio/text-to-speech/text-to-speech
+ */
+import type { TTSHandler, TTSOptions, TTSResult } from "../../types/index.js";
+/**
+ * Fish Audio Text-to-Speech Handler.
+ *
+ * Auth: `Authorization: Bearer ${FISH_AUDIO_API_KEY}`.
+ * Models: speech-1.5 (standard), speech-1.6, s1 (default; latest).
+ */
+export declare class FishAudioTTS implements TTSHandler {
+    readonly maxTextLength = 5000;
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(apiKey?: string);
+    isConfigured(): boolean;
+    synthesize(text: string, options?: TTSOptions): Promise<TTSResult>;
+    private mapFormat;
+    private effectiveFormat;
+    private getSampleRate;
+}

package/dist/lib/voice/providers/FishAudioTTS.js

@@ -0,0 +1,183 @@
+/**
+ * Fish Audio TTS Handler
+ *
+ * Implementation of TTS using Fish Audio API. Lower-cost alternative to
+ * ElevenLabs with strong multilingual support and 15s voice cloning.
+ *
+ * @module voice/providers/FishAudioTTS
+ * @see https://docs.fish.audio/text-to-speech/text-to-speech
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { logger } from "../../utils/logger.js";
+import { TTS_ERROR_CODES, TTSError } from "../../utils/ttsProcessor.js";
+const DEFAULT_BASE_URL = "https://api.fish.audio";
+const REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Default reference voice — "Energetic Male" by official author `lengyue`,
+ * a long-standing public English voice on Fish Audio.
+ *
+ * @see https://fish.audio (model id 802e3bc2b27e49c2995d23ef70e6ac89)
+ *
+ * Note: the previous default `fb6c0e1ea91e427fb9a93b9bbf0a1e4d` was
+ * removed upstream and started returning 400 "Reference not found".
+ */
+const DEFAULT_REFERENCE_ID = "802e3bc2b27e49c2995d23ef70e6ac89";
+/**
+ * Fish Audio Text-to-Speech Handler.
+ *
+ * Auth: `Authorization: Bearer ${FISH_AUDIO_API_KEY}`.
+ * Models: speech-1.5 (standard), speech-1.6, s1 (default; latest).
+ */
+export class FishAudioTTS {
+    maxTextLength = 5000;
+    apiKey;
+    baseUrl;
+    constructor(apiKey) {
+        const resolved = (apiKey ?? process.env.FISH_AUDIO_API_KEY ?? "").trim();
+        this.apiKey = resolved.length > 0 ? resolved : null;
+        this.baseUrl = (process.env.FISH_AUDIO_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    }
+    isConfigured() {
+        return this.apiKey !== null;
+    }
+    async synthesize(text, options = {}) {
+        if (!this.apiKey) {
+            throw new TTSError({
+                code: TTS_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                message: "FISH_AUDIO_API_KEY not configured",
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        const startTime = Date.now();
+        const referenceId = options.voice ?? DEFAULT_REFERENCE_ID;
+        const requestedFormat = options.format ?? "mp3";
+        const upstreamFormat = this.mapFormat(requestedFormat);
+        const body = {
+            text,
+            reference_id: referenceId,
+            format: upstreamFormat,
+            mp3_bitrate: 128,
+            chunk_length: 200,
+            normalize: true,
+            latency: "normal",
+        };
+        const fishOpts = options;
+        if (fishOpts.model) {
+            body.model = fishOpts.model;
+        }
+        if (fishOpts.latency) {
+            body.latency = fishOpts.latency;
+        }
+        if (fishOpts.mp3Bitrate !== undefined) {
+            body.mp3_bitrate = fishOpts.mp3Bitrate;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(`${this.baseUrl}/v1/tts`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new TTSError({
+                    code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                    message: `Fish Audio request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: true,
+                    originalError: err,
+                });
+            }
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Fish Audio network error: ${err instanceof Error ? err.message : String(err)}`,
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                retriable: true,
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            const retriable = response.status === 408 ||
+                response.status === 429 ||
+                response.status >= 500;
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Fish Audio synthesis failed: ${response.status} — ${text}`,
+                category: retriable ? ErrorCategory.NETWORK : ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable,
+                context: { status: response.status, referenceId, upstreamFormat },
+            });
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = Buffer.from(arrayBuffer);
+        const latency = Date.now() - startTime;
+        const effectiveFormat = this.effectiveFormat(upstreamFormat);
+        const result = {
+            buffer: audioBuffer,
+            format: effectiveFormat,
+            size: audioBuffer.length,
+            voice: referenceId,
+            sampleRate: this.getSampleRate(effectiveFormat),
+            metadata: {
+                latency,
+                provider: "fish-audio",
+                model: fishOpts.model ?? "s1",
+                requestedFormat: options.format,
+                upstreamFormat,
+            },
+        };
+        logger.info(`[FishAudioTTS] Synthesized ${audioBuffer.length} bytes in ${latency}ms`);
+        return result;
+    }
+    mapFormat(format) {
+        const supported = {
+            mp3: "mp3",
+            wav: "wav",
+            pcm16: "pcm",
+        };
+        const mapped = supported[format];
+        if (!mapped) {
+            logger.warn(`[FishAudioTTS] Unsupported format "${format}" — falling back to "mp3"`);
+            return "mp3";
+        }
+        return mapped;
+    }
+    effectiveFormat(upstreamFormat) {
+        if (upstreamFormat === "mp3") {
+            return "mp3";
+        }
+        if (upstreamFormat === "wav") {
+            return "wav";
+        }
+        if (upstreamFormat === "pcm") {
+            return "pcm16";
+        }
+        return "mp3";
+    }
+    getSampleRate(format) {
+        if (format === "wav") {
+            return 44_100;
+        }
+        if (format === "pcm16") {
+            return 44_100;
+        }
+        return 44_100;
+    }
+}
+//# sourceMappingURL=FishAudioTTS.js.map

package/dist/lib/workflow/core/ensembleExecutor.js

@@ -120,15 +120,32 @@ async function executeModel(options, workflowDefaultSystemPrompt) {
         // 3. Workflow-level default
         // 4. undefined (provider default)
         const resolvedSystemPrompt = systemPrompt || model.systemPrompt || workflowDefaultSystemPrompt;
-        // Execute with timeout
-        const result = await executeWithTimeout(async () => {
-            return await provider.generate({
-                prompt,
-                systemPrompt: resolvedSystemPrompt,
-                temperature: model.temperature,
-                maxTokens: model.maxTokens,
-            });
-        }, timeout, `Model ${model.provider}/${model.model} timed out after ${timeout}ms`);
+        // Execute with timeout. Some upstream LLM endpoints (notably Vertex
+        // under high parallel load) occasionally respond with an empty
+        // assistant message instead of content; retry once before giving up so
+        // a transient empty response doesn't cascade into an empty ensemble
+        // result that downstream tests + judges have no way to evaluate.
+        let result;
+        let attempts = 0;
+        const MAX_ATTEMPTS = 2;
+        /* eslint-disable no-constant-condition */
+        while (true) {
+            attempts++;
+            result = await executeWithTimeout(async () => {
+                return await provider.generate({
+                    prompt,
+                    systemPrompt: resolvedSystemPrompt,
+                    temperature: model.temperature,
+                    maxTokens: model.maxTokens,
+                });
+            }, timeout, `Model ${model.provider}/${model.model} timed out after ${timeout}ms`);
+            const contentLen = result?.content?.length ?? 0;
+            if (contentLen > 0 || attempts >= MAX_ATTEMPTS) {
+                break;
+            }
+            logger.warn(`[${functionTag}] Model returned empty content — retrying once`, { provider: model.provider, model: model.model, attempt: attempts });
+        }
+        /* eslint-enable no-constant-condition */
         const responseTime = Date.now() - startTime;
         logger.debug(`[${functionTag}] Model execution successful`, {
             provider: model.provider,

package/dist/memory/hippocampusInitializer.d.ts

@@ -1,2 +1,2 @@
-import { Hippocampus, type HippocampusConfig } from "@juspay/hippocampus";
-export declare function initializeHippocampus(config: HippocampusConfig): Hippocampus | null;
+import type { HippocampusConfig, HippocampusLike } from "../types/index.js";
+export declare function initializeHippocampus(config: HippocampusConfig): HippocampusLike | null;

package/dist/memory/hippocampusInitializer.js

@@ -1,8 +1,38 @@
-import { Hippocampus } from "@juspay/hippocampus";
+import { createRequire } from "node:module";
 import { logger } from "../utils/logger.js";
+// Lazy require so importing NeuroLink core does not fail when the optional
+// peer @juspay/hippocampus is not installed. The package was previously a
+// hard runtime dependency, but Hippocampus declares a peer on
+// @juspay/neurolink which made pnpm pull a registry NeuroLink that
+// transitively required @ai-sdk/google + @ai-sdk/google-vertex into the
+// production graph. Making memory optional breaks that cycle while keeping
+// the same runtime behavior whenever the package is installed.
+const lazyRequire = createRequire(import.meta.url);
+let cachedModule;
+function loadHippocampusModule() {
+    if (cachedModule !== undefined) {
+        return cachedModule;
+    }
+    try {
+        cachedModule = lazyRequire("@juspay/hippocampus");
+        return cachedModule;
+    }
+    catch (error) {
+        cachedModule = null;
+        logger.debug("[memoryInitializer] @juspay/hippocampus is not installed; memory features disabled.", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
 export function initializeHippocampus(config) {
+    const mod = loadHippocampusModule();
+    if (!mod) {
+        logger.warn("[memoryInitializer] Memory configuration provided but @juspay/hippocampus is not installed. Run `pnpm add @juspay/hippocampus` (or your package manager equivalent) to enable memory.");
+        return null;
+    }
     try {
-        const instance = new Hippocampus(config);
+        const instance = new mod.Hippocampus(config);
         logger.info("[memoryInitializer] Memory initialized successfully", {
             storageType: config.storage?.type || "sqlite",
             maxWords: config.maxWords || 50,