@juspay/neurolink 11.29.0 → 11.29.2

package/dist/core/baseProvider.js

@@ -2176,11 +2176,16 @@ export class BaseProvider {
         // shared timeout helper so standard video gen honors the caller's
         // timeout the same way director mode does (see above ~Line 2062).
         const videoTimeout = options.timeout ?? 600_000; // 10 min default
+        // Thread the caller's cancellation signal into the handler chain —
+        // output.video.abortSignal (video-scoped) wins over the request-level
+        // options.abortSignal, matching the general per-field precedence.
+        const videoAbortSignal = options.output?.video?.abortSignal ?? options.abortSignal;
         const videoResult = await this.executeWithTimeout(() => VideoProcessor.generate(requestedProvider, {
             ...(options.output?.video ?? {}),
             image: imageBuffer,
             prompt,
             region: options.region,
+            abortSignal: videoAbortSignal,
         }), { timeout: videoTimeout, operationType: "generate" });
         // Prefer the handler's own model id (more accurate — it knows the exact
         // checkpoint that ran). Fall back to the request-time value, and finally

package/dist/core/resolveRequestKind.d.ts

@@ -7,11 +7,10 @@ import type { RequestKind, RequestKindInput } from "../types/index.js";
  * stream()/runGenerateInActiveContext (image/video/tts-direct routing) call
  * this instead of independently re-deriving the decision.
  *
- * NOT yet the only copy: replicate.ts's generate() override and
- * googleVertex/client.ts's native dispatch (~6672-6718) still carry their
- * own provider-internal versions — the Vertex one with a cruder
- * startsWith() image match. Migrating those two is queued follow-up work;
- * until it lands, an edit to this precedence table does not reach them.
+ * Also the only copy at the provider-override level: replicate.ts's
+ * generate() override and googleVertex/client.ts's generate()/stream()
+ * overrides (which bypass BaseProvider's paths) call this too, so an edit
+ * to this precedence table reaches every dispatch site.
  *
  * Precedence, checked in order:
  *   1. output.mode (music/avatar/video/ppt) — an explicit mode always wins.

package/dist/core/resolveRequestKind.js

@@ -7,11 +7,10 @@ import { isImageGenerationModel } from "./constants.js";
  * stream()/runGenerateInActiveContext (image/video/tts-direct routing) call
  * this instead of independently re-deriving the decision.
  *
- * NOT yet the only copy: replicate.ts's generate() override and
- * googleVertex/client.ts's native dispatch (~6672-6718) still carry their
- * own provider-internal versions — the Vertex one with a cruder
- * startsWith() image match. Migrating those two is queued follow-up work;
- * until it lands, an edit to this precedence table does not reach them.
+ * Also the only copy at the provider-override level: replicate.ts's
+ * generate() override and googleVertex/client.ts's generate()/stream()
+ * overrides (which bypass BaseProvider's paths) call this too, so an edit
+ * to this precedence table reaches every dispatch site.
  *
  * Precedence, checked in order:
  *   1. output.mode (music/avatar/video/ppt) — an explicit mode always wins.

package/dist/providers/googleVertex/client.js

@@ -8,7 +8,8 @@ import { BaseProvider } from "../../core/baseProvider.js";
 import { unwrapImagePayload } from "../../adapters/imageFormatSupport.js";
 import { appendNativeAudioParts } from "../googleNativeGemini3/utils.js";
 import { getMimeTypeForExtension } from "../../processors/config/mimeConstants.js";
-import { DEFAULT_GEMINI_STREAM_TIMEOUT_MS, DEFAULT_MAX_STEPS, DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../../core/constants.js";
+import { DEFAULT_GEMINI_STREAM_TIMEOUT_MS, DEFAULT_MAX_STEPS, DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../../core/constants.js";
+import { resolveRequestKind } from "../../core/resolveRequestKind.js";
 import { ModelConfigurationManager } from "../../core/modelConfiguration.js";
 import { isSchemaComplexityError } from "../../core/modules/structuredOutputPolicy.js";
 import { redactUrlForError, stringifyContentSafe, } from "../../utils/logSanitize.js";
@@ -5089,9 +5090,11 @@ export class GoogleVertexProvider extends BaseProvider {
             ? { input: { text: optionsOrPrompt } }
             : optionsOrPrompt;
         const modelName = options.model || this.modelName || getDefaultVertexModel();
-        // Check if this is an image generation model - image models don't support streaming
-        const isImageModel = IMAGE_GENERATION_MODELS.some((m) => modelName.toLowerCase().startsWith(m.toLowerCase()));
-        if (isImageModel) {
+        // Image-generation requests can't stream — fall back to generate.
+        // Same single dispatch decision as generate(): resolveRequestKind
+        // keeps dual-mode models streaming text when the caller explicitly
+        // asked for a non-image output.format.
+        if (resolveRequestKind(options, modelName) === "image") {
             logger.warn("[GoogleVertex] Image generation models don't support streaming, falling back to generate", { model: modelName });
             // Convert stream options to text generation options
             const generateOptions = {
@@ -5150,13 +5153,20 @@ export class GoogleVertexProvider extends BaseProvider {
             },
         }, async (generateSpan) => {
             const generateStartTime = Date.now();
+            // One dispatch decision for the whole override: Vertex's generate()
+            // bypasses BaseProvider.generate(), so it re-runs the same
+            // resolveRequestKind() the core call sites use rather than keeping
+            // a hand-rolled copy of the precedence (which had drifted: tts
+            // checked before image, and a cruder case-insensitive startsWith
+            // image match without boundary awareness).
+            const requestKind = resolveRequestKind(options, modelName);
             // Video-mode requests must route through BaseProvider's
             // handleVideoGeneration (which loads the Veo 3 adapter). Vertex's
             // native @google/genai path is text/image only — without this
             // gate, video requests fall through to gemini-2.5-flash and the
             // model politely declines ("I cannot create animations") instead
             // of producing video bytes.
-            if (options.output?.mode === "video") {
+            if (requestKind === "video") {
                 logger.info("[GoogleVertex] Routing video-mode generate to handleVideoGeneration", { model: modelName });
                 const videoResult = await this.handleVideoGeneration(options, generateStartTime);
                 this.attachUsageAndCostAttributes(generateSpan, modelName, videoResult?.usage);
@@ -5168,15 +5178,17 @@ export class GoogleVertexProvider extends BaseProvider {
             // (synthesise the input text directly; no LLM call). BaseProvider's
             // standard generate() does the same dispatch — we replicate it here
             // because Vertex's override bypasses that path.
-            if (options.tts?.enabled && !options.tts?.useAiResponse) {
+            if (requestKind === "tts-direct") {
                 logger.info("[GoogleVertex] Routing TTS direct-synthesis to handleDirectTTSSynthesis", { model: modelName });
                 const ttsResult = await this.handleDirectTTSSynthesis(options, generateStartTime);
                 this.emitGenerationEnd(modelName, ttsResult, generateStartTime, true);
                 return ttsResult;
             }
-            // Check if this is an image generation model - route to executeImageGeneration without tools
-            const isImageModel = IMAGE_GENERATION_MODELS.some((m) => modelName.toLowerCase().startsWith(m.toLowerCase()));
-            if (isImageModel) {
+            // Image-generation models route to executeImageGeneration without
+            // tools. resolveRequestKind also carries the dual-mode exception:
+            // an explicit non-image output.format keeps models like
+            // gemini-3.1-flash-image-preview on the text path.
+            if (requestKind === "image") {
                 logger.info("[GoogleVertex] Routing image generation model to executeImageGeneration", { model: modelName });
                 const imageResult = await this.executeImageGeneration(options);
                 this.attachUsageAndCostAttributes(generateSpan, modelName, imageResult?.usage);

package/dist/providers/replicate.js

@@ -1,5 +1,6 @@
 import { ErrorCategory, ErrorSeverity, ReplicateModels, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import { resolveRequestKind } from "../core/resolveRequestKind.js";
 import { getReplicateAuth } from "../adapters/replicate/auth.js";
 import { downloadPredictionOutput, predict, } from "../adapters/replicate/predictionLifecycle.js";
 import { MAX_IMAGE_BYTES } from "../utils/sizeGuard.js";
@@ -121,19 +122,18 @@ export class ReplicateProvider extends BaseProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { isImageGenerationModel } = await import("../core/constants.js");
-        // Delegate special output modes to base class (which never calls getAISDKModel for these)
-        if (options.output?.mode === "video" ||
-            options.output?.mode === "avatar" ||
-            options.output?.mode === "music") {
-            return super.generate(options, _analysisSchema);
-        }
-        // Image-gen models: delegate to base which calls executeImageGeneration()
-        const isImageModel = isImageGenerationModel(this.modelName);
-        const requestsNonImageOutput = options.output?.format === "json" ||
-            options.output?.format === "structured" ||
-            options.output?.format === "text";
-        if (isImageModel && !requestsNonImageOutput) {
+        // Delegate media kinds to the base class (which never calls
+        // getAISDKModel for these). resolveRequestKind owns the precedence —
+        // including the dual-mode exception where an explicit non-image
+        // output.format keeps an image-gen model on the text path. "ppt" and
+        // "tts-direct" deliberately stay on the local text path below:
+        // super.generate() would hit prepareGenerationContext() →
+        // getAISDKModel(), which throws for Replicate.
+        const kind = resolveRequestKind(options, this.modelName);
+        if (kind === "video" ||
+            kind === "avatar" ||
+            kind === "music" ||
+            kind === "image") {
             return super.generate(options, _analysisSchema);
         }
         // Structured / JSON output is not natively supported by the Replicate

package/dist/types/video.d.ts

@@ -34,6 +34,11 @@ export type VideoGenerateOptions = VideoOutputOptions & {
  * `generateTransition` method on `VideoHandler`.
  */
 export type VideoTransitionOptions = {
+    /**
+     * Per-call cancellation signal forwarded to provider requests and polling
+     * loops — same contract as `VideoOutputOptions.abortSignal`.
+     */
+    abortSignal?: AbortSignal;
     aspectRatio?: "9:16" | "16:9" | "1:1" | string;
     resolution?: "720p" | "1080p";
     audio?: boolean;

package/dist/utils/videoProcessor.js

@@ -84,6 +84,16 @@ export class VideoProcessor {
             }
             : optionsOrImage;
         const { image, prompt, region, ...videoOptions } = bag;
+        // A fired timeout must also cancel the handler's own request/polling
+        // loop — otherwise the caller sees the rejection while a ghost
+        // generation keeps polling (and possibly billing) for the rest of the
+        // render. Chain the internal controller onto any caller-supplied
+        // signal so both cancellation sources reach the handler.
+        const timeoutAbort = new AbortController();
+        const abortSignal = videoOptions.abortSignal
+            ? AbortSignal.any([videoOptions.abortSignal, timeoutAbort.signal])
+            : timeoutAbort.signal;
+        const handlerOptions = { ...videoOptions, abortSignal };
         const span = SpanSerializer.createSpan(SpanType.MEDIA_GENERATION, "video.generate", this.buildSpanAttributes(provider, videoOptions));
         try {
             const handler = this.getHandler(provider);
@@ -111,13 +121,17 @@ export class VideoProcessor {
             // Bounded per repo guideline (async provider calls wrap withTimeout):
             // video generation is legitimately slow, so the deadline is generous —
             // but a wedged handler must error, never hang the caller forever.
-            const result = await withTimeout(handler.generate(image, prompt, videoOptions, region), VIDEO_GENERATION_TIMEOUT_MS, `Video generation via "${provider}" timed out after ${VIDEO_GENERATION_TIMEOUT_MS}ms`);
+            const result = await withTimeout(handler.generate(image, prompt, handlerOptions, region), VIDEO_GENERATION_TIMEOUT_MS, `Video generation via "${provider}" timed out after ${VIDEO_GENERATION_TIMEOUT_MS}ms`);
             const ended = SpanSerializer.endSpan(span, SpanStatus.OK);
             getMetricsAggregator().recordSpan(ended);
             logger.info(`[VideoProcessor] Generated ${result.data.length} bytes (${provider})`);
             return result;
         }
         catch (err) {
+            // Cancel the ghost: on timeout the handler promise is still pending;
+            // aborting here stops its polling loop. On handler-originated errors
+            // the promise has already settled, so the abort is a no-op.
+            timeoutAbort.abort();
             const ended = SpanSerializer.endSpan(span, SpanStatus.ERROR, err instanceof Error ? err.message : String(err));
             getMetricsAggregator().recordSpan(ended);
             if (err instanceof VideoError) {
@@ -174,11 +188,22 @@ export class VideoProcessor {
                 context: { provider },
             });
         }
+        // Same ghost-cancellation contract as generate(): a fired timeout
+        // aborts the handler's polling loop, chained onto any caller signal.
+        const timeoutAbort = new AbortController();
+        const abortSignal = options?.abortSignal
+            ? AbortSignal.any([options.abortSignal, timeoutAbort.signal])
+            : timeoutAbort.signal;
+        const handlerOptions = {
+            ...(options ?? {}),
+            abortSignal,
+        };
         try {
             // Same bound as generate(): a wedged transition must error, not hang.
-            return await withTimeout(handler.generateTransition(firstFrame, lastFrame, prompt, options, region), VIDEO_GENERATION_TIMEOUT_MS, `Video transition via "${provider}" timed out after ${VIDEO_GENERATION_TIMEOUT_MS}ms`);
+            return await withTimeout(handler.generateTransition(firstFrame, lastFrame, prompt, handlerOptions, region), VIDEO_GENERATION_TIMEOUT_MS, `Video transition via "${provider}" timed out after ${VIDEO_GENERATION_TIMEOUT_MS}ms`);
         }
         catch (err) {
+            timeoutAbort.abort();
             if (err instanceof VideoError) {
                 throw err;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.29.0",
+  "version": "11.29.2",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -114,6 +114,7 @@
     "test:skills": "pnpm exec tsx test/continuous-test-suite-skills.ts",
     "test:servers": "pnpm exec tsx test/continuous-test-suite-servers.ts",
     "test:tool-reliability": "pnpm exec tsx test/continuous-test-suite-tool-reliability.ts",
+    "test:video-abort": "pnpm exec tsx test/continuous-test-suite-video-abort.ts",
     "test:tts": "pnpm exec tsx test/continuous-test-suite-tts.ts",
     "test:tts:unit": "pnpm exec tsx test/continuous-test-suite-tts-unit.ts",
     "test:stt:unit": "pnpm exec tsx test/continuous-test-suite-stt-unit.ts",