@juspay/neurolink 9.63.1 → 9.65.0

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

@@ -163,6 +163,141 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    xai?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    groq?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    cohere?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    together?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    fireworks?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    perplexity?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    cloudflare?: {
+        apiKey?: string;
+        accountId?: string;
+        baseURL?: string;
+    };
+    replicate?: {
+        apiToken?: string;
+        baseUrl?: string;
+    };
+    voyage?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    jina?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    stability?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    ideogram?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    recraft?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+};
+/**
+ * Voyage AI /embeddings response shape.
+ */
+export type VoyageEmbeddingsResponse = {
+    object: "list";
+    data: {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }[];
+    model: string;
+    usage?: {
+        total_tokens?: number;
+    };
+};
+/**
+ * Jina AI /embeddings response shape (compatible with OpenAI's shape).
+ */
+export type JinaEmbeddingsResponse = {
+    object?: string;
+    data: {
+        object?: string;
+        embedding: number[];
+        index: number;
+    }[];
+    model?: string;
+    usage?: {
+        total_tokens?: number;
+        prompt_tokens?: number;
+    };
+};
+/**
+ * Jina AI /rerank response shape.
+ */
+export type JinaRerankResponse = {
+    model?: string;
+    results: {
+        index: number;
+        relevance_score: number;
+        document?: {
+            text?: string;
+        };
+    }[];
+    usage?: {
+        total_tokens?: number;
+    };
+};
+/**
+ * Stability AI /v2beta/stable-image/generate/{model} response shape
+ * (returns either binary directly, or JSON with base64 when Accept is set
+ * to application/json). We always request JSON for uniformity.
+ */
+export type StabilityImageResponse = {
+    image?: string;
+    finish_reason?: "SUCCESS" | "ERROR" | "CONTENT_FILTERED";
+    seed?: number;
+};
+/**
+ * Ideogram /api/v1/ideogram-v3/generate response shape.
+ */
+export type IdeogramImageResponse = {
+    created?: string;
+    data: {
+        prompt?: string;
+        resolution?: string;
+        is_image_safe?: boolean;
+        seed?: number;
+        url?: string;
+        style_type?: string;
+    }[];
+};
+/**
+ * Recraft /v1/images/generations response shape.
+ */
+export type RecraftImageResponse = {
+    created?: number;
+    data: {
+        url?: string;
+        b64_json?: string;
+        image_id?: string;
+    }[];
 };
 /**
  * NVIDIA NIM extra request body parameters passed via `providerOptions.openai.body`.
@@ -703,6 +838,15 @@ export type GenAIModelsAPI = {
         }>;
         config?: Record<string, unknown>;
     }) => Promise<GenAIGenerateContentResponse>;
+    embedContent: (params: {
+        model: string;
+        contents: string | string[];
+        config?: Record<string, unknown>;
+    }) => Promise<{
+        embeddings?: Array<{
+            values?: number[];
+        }>;
+    }>;
 };
 /**
  * Google AI client interface
@@ -713,17 +857,52 @@ export type GenAIClient = {
     };
     models: GenAIModelsAPI;
 };
+/**
+ * HTTP options for Google GenAI SDK
+ * Allows custom fetch implementation for proxy support
+ */
+export type GoogleGenAIHttpOptions = {
+    /** Custom fetch implementation for proxy support */
+    fetch?: typeof fetch;
+};
 /**
  * Google GenAI constructor type
  * Supports both API key (Google AI Studio) and Vertex AI configurations
  */
 export type GoogleGenAIClass = new (cfg: {
     apiKey: string;
+    httpOptions?: GoogleGenAIHttpOptions;
 } | {
     vertexai: boolean;
     project: string;
     location: string;
+    httpOptions?: GoogleGenAIHttpOptions;
 }) => GenAIClient;
+/**
+ * Google Vertex AI provider settings for native SDK configuration
+ * Used with @google/genai SDK in vertexai mode
+ *
+ * Note: Authentication is handled via environment variables (GOOGLE_APPLICATION_CREDENTIALS)
+ * or the temporary credentials file approach, not through these settings fields.
+ */
+export type GoogleVertexProviderSettings = {
+    /** Google Cloud project ID */
+    project: string;
+    /** Google Cloud region/location (e.g., 'us-central1') */
+    location: string;
+    /** Optional custom fetch implementation */
+    fetch?: typeof fetch;
+};
+/**
+ * Anthropic Vertex AI settings for Claude models on Vertex
+ * Used with @anthropic-ai/vertex-sdk
+ */
+export type AnthropicVertexSettings = {
+    /** Google Cloud project ID */
+    projectId: string;
+    /** Google Cloud region for Anthropic models (e.g., 'us-east5') */
+    region: string;
+};
 /**
  * OpenAI-compatible models endpoint response structure
  */
@@ -1429,10 +1608,18 @@ export type NativeFunctionDeclaration = {
 export type NativeToolsConfig = Array<{
     functionDeclarations: NativeFunctionDeclaration[];
 }>;
-/** Return value of buildNativeToolDeclarations. */
+/**
+ * Return value of buildNativeToolDeclarations.
+ *
+ * `originalNameMap` lets callers translate a Google-safe (sanitized,
+ * suffix-disambiguated) tool name back to the original identifier the
+ * SDK consumer registered. Sanitized names are transport-only — they
+ * MUST be hidden from tool-call metadata exposed to consumers.
+ */
 export type NativeToolDeclarationsResult = {
     toolsConfig: NativeToolsConfig;
     executeMap: Map<string, Tool["execute"]>;
+    originalNameMap: Map<string, string>;
 };
 /** A single function call returned by the Gemini model. */
 export type NativeFunctionCall = {
@@ -1499,8 +1686,8 @@ export type ToolWithLegacyParams = {
  * factory functions.
  */
 export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
 /** Provider registration entry held by ProviderFactory. */
 export type ProviderRegistration = {
     constructor: ProviderConstructor;
@@ -1603,6 +1790,9 @@ export type GoogleLiveAudioQueueItem = {
 /**
  * Single part inside a Google Vertex "native" (non-AI-SDK) generateContent
  * payload — either inline text or an inline base64 data blob.
+ *
+ * Despite the "Vertex" prefix, the shape is identical for the Google AI
+ * Studio native path (`@google/genai` SDK), so AI Studio re-uses this type.
  */
 export type VertexNativePart = {
     text: string;
@@ -1612,6 +1802,21 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Subset of `GenerateOptions["input"]` consumed by the shared Gemini-native
+ * multimodal-parts builder. Kept narrow so the helper doesn't depend on the
+ * full `GenerateOptions` shape. The `images` field mirrors the public
+ * `GenerateOptions["input"].images` shape so the helper accepts the same
+ * value SDK callers pass in (plain Buffer/string or `ImageWithAltText`).
+ */
+export type GeminiMultimodalInput = {
+    text?: string;
+    pdfFiles?: Array<Buffer | string>;
+    images?: Array<Buffer | string | {
+        data: Buffer | string;
+        altText?: string;
+    }>;
+};
 /**
  * Internal helpers used by the conversation-history builder in
  * providers/googleVertex.ts to merge interleaved tool call / result turns.
@@ -1627,3 +1832,79 @@ export type VertexRegularSegment = {
     parts: unknown[];
 };
 export type VertexSegment = VertexToolStep | VertexRegularSegment;
+/**
+ * Function declaration shape accepted by the @google/genai SDK when tools are
+ * attached to a Vertex generateContent call.
+ */
+export type VertexGenaiFunctionDeclaration = {
+    name: string;
+    description: string;
+    parametersJsonSchema?: Record<string, unknown>;
+};
+/**
+ * Message payload passed to the Anthropic Vertex SDK — mirrors the Anthropic
+ * Messages API shape (role + structured content blocks).
+ */
+export type VertexAnthropicMessage = {
+    role: "user" | "assistant";
+    content: string | Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "document";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: unknown;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string;
+    } | {
+        type: "thinking";
+        thinking: string;
+    } | {
+        type: "redacted_thinking";
+        data: string;
+    }>;
+};
+/** Tool definition accepted by the Anthropic Vertex SDK. */
+export type VertexAnthropicTool = {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+};
+/**
+ * Content block variants returned by the Anthropic Vertex SDK during streaming
+ * and generation — used to narrow responses before handing tool calls back.
+ */
+export type VertexAnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};

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

@@ -0,0 +1,67 @@
+/**
+ * Replicate Type Definitions
+ *
+ * Shared types for the Replicate prediction lifecycle (LLM, video,
+ * avatar, music handlers all consume these via the types barrel).
+ *
+ * @module types/replicate
+ */
+/**
+ * Replicate auth payload — bearer token + optional base URL.
+ */
+export type ReplicateAuth = {
+    apiToken: string;
+    baseUrl?: string;
+};
+/**
+ * Replicate prediction status (terminal: succeeded / failed / canceled).
+ */
+export type ReplicatePredictionStatus = "starting" | "processing" | "succeeded" | "failed" | "canceled";
+/**
+ * Replicate prediction object as returned by /v1/predictions POST and
+ * /v1/predictions/:id GET. Output shape varies by model — caller narrows.
+ */
+export type ReplicatePrediction = {
+    id: string;
+    model?: string;
+    version?: string;
+    status: ReplicatePredictionStatus;
+    /** URL string, array of URL strings, base64, or model-specific JSON. */
+    output?: unknown;
+    error?: string | null;
+    metrics?: {
+        predict_time?: number;
+    };
+    urls?: {
+        get: string;
+        cancel: string;
+    };
+    logs?: string;
+    created_at?: string;
+    started_at?: string;
+    completed_at?: string;
+};
+/**
+ * Input shape for Replicate's createPrediction helper.
+ */
+export type ReplicateCreatePredictionInput = {
+    /** Model in "owner/name" or "owner/name:version" form. */
+    model: string;
+    /** Provider/model-specific input shape. */
+    input: Record<string, unknown>;
+    /** Optional webhook URL for completion notifications. */
+    webhook?: string;
+    /** Optional webhook events filter. */
+    webhookEventsFilter?: ("start" | "output" | "logs" | "completed")[];
+};
+/**
+ * Options for the Replicate poll loop.
+ */
+export type ReplicatePollOptions = {
+    /** Total time to wait before throwing a timeout error (default 5 min). */
+    timeoutMs?: number;
+    /** Poll interval in milliseconds (default 2 s). */
+    pollIntervalMs?: number;
+    /** Caller-supplied AbortSignal to cancel polling early. */
+    abortSignal?: AbortSignal;
+};

package/dist/lib/types/replicate.js

@@ -0,0 +1,10 @@
+/**
+ * Replicate Type Definitions
+ *
+ * Shared types for the Replicate prediction lifecycle (LLM, video,
+ * avatar, music handlers all consume these via the types barrel).
+ *
+ * @module types/replicate
+ */
+export {};
+//# sourceMappingURL=replicate.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Types for the safe-fetch utility (SSRF-hardened binary downloads).
+ *
+ * Runtime helper lives in `src/lib/utils/safeFetch.ts`.
+ */
+export type SafeDownloadOptions = {
+    /** Hard cap on response size in bytes. Pass MAX_VIDEO_BYTES/MAX_AUDIO_BYTES/MAX_IMAGE_BYTES from sizeGuard. */
+    maxBytes: number;
+    /** Human-readable identifier used in error messages (e.g. "HeyGen video"). */
+    label: string;
+    /** Optional abort signal for caller-driven cancellation. */
+    signal?: AbortSignal;
+    /** Optional per-call request timeout (ms). Default: 60_000. */
+    timeoutMs?: number;
+};

package/dist/lib/types/safeFetch.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the safe-fetch utility (SSRF-hardened binary downloads).
+ *
+ * Runtime helper lives in `src/lib/utils/safeFetch.ts`.
+ */
+export {};
+//# sourceMappingURL=safeFetch.js.map

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

@@ -167,7 +167,8 @@ export type StreamChunk = {
 };
 export type StreamOptions = {
     input: {
-        text: string;
+        /** Prompt text. Optional for media-only modes (avatar, music) that are driven by uploaded files rather than a prompt. */
+        text?: string;
         audio?: AudioInputSpec;
         /**
          * Images to include in the request.
@@ -314,6 +315,12 @@ export type StreamOptions = {
     region?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Top-p (nucleus) sampling parameter. Controls diversity of generated tokens. */
+    topP?: number;
+    /** Top-k sampling parameter. Limits the number of tokens considered. (Google/Gemini models only) */
+    topK?: number;
+    /** Stop sequences that will halt generation when encountered. */
+    stopSequences?: string[];
     systemPrompt?: string;
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;

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

@@ -515,3 +515,16 @@ export declare function isToolResult(value: unknown): value is ToolResult;
  * Type guard for tool definition
  */
 export declare function isToolDefinition(value: unknown): value is ToolDefinition;
+/**
+ * Result shape returned by the built-in `bashTool` execute function in
+ * `src/lib/agent/directTools.ts`. Centralised here per CLAUDE.md rule 2
+ * so callers (incl. the mcp-bash test suite) don't need to declare a
+ * local re-shaping of the runtime contract.
+ */
+export type BashToolResult = {
+    success: boolean;
+    code: number;
+    stdout: string;
+    stderr: string;
+    error?: string;
+};

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

@@ -0,0 +1,89 @@
+/**
+ * Video Generation Type Definitions
+ *
+ * Shared types for video generation across providers (Vertex Veo, Kling,
+ * Runway, Replicate-hosted models, etc.).
+ *
+ * The shared base shapes (`VideoOutputOptions`, `VideoGenerationResult`)
+ * are defined in `multimodal.ts` for backwards compatibility — they are
+ * re-exported here so callers can import every video-related type from a
+ * single module.
+ *
+ * @module types/video
+ */
+import type { VideoGenerationResult, VideoOutputOptions } from "./multimodal.js";
+export type { VideoGenerationResult, VideoOutputOptions, } from "./multimodal.js";
+/**
+ * Director-mode transition options.
+ *
+ * Used by handlers that support first-and-last-frame interpolation
+ * (e.g., Veo 3.1 Fast). Providers without transition support omit the
+ * `generateTransition` method on `VideoHandler`.
+ */
+export type VideoTransitionOptions = {
+    aspectRatio?: "9:16" | "16:9" | "1:1" | string;
+    resolution?: "720p" | "1080p";
+    audio?: boolean;
+    /** Duration of the transition clip (Veo accepts 4, 6, or 8). Default 4. */
+    durationSeconds?: 4 | 6 | 8;
+};
+/**
+ * Handler contract for video generation providers.
+ *
+ * Every concrete handler (`VertexVideoHandler`, `KlingVideoHandler`,
+ * `RunwayVideoHandler`, `ReplicateVideoHandler`, …) implements this
+ * interface and registers itself with `VideoProcessor.registerHandler`.
+ *
+ * Implementations MUST enforce their own timeouts. The recommended
+ * total-deadline for image-to-video predictLongRunning APIs is
+ * 3-5 minutes; the per-request fetch timeout is 30 seconds.
+ */
+export type VideoHandler = {
+    /**
+     * Generate a single video clip from an input image and prompt.
+     *
+     * @param image - Input image buffer (JPEG, PNG, or WebP)
+     * @param prompt - Text prompt describing desired video motion / content
+     * @param options - Resolution, length, aspect ratio, audio settings
+     * @param region - Provider-specific region override (e.g. Vertex location)
+     * @returns Buffer + metadata
+     */
+    generate(image: Buffer, prompt: string, options: VideoOutputOptions, region?: string): Promise<VideoGenerationResult>;
+    /**
+     * Optional — generate a transition clip between two frames (Director Mode).
+     *
+     * Providers without first-and-last-frame interpolation omit this method;
+     * `VideoProcessor.generateTransition` will surface a typed error.
+     *
+     * `durationSeconds` is on `VideoTransitionOptions` (default 4).
+     */
+    generateTransition?(firstFrame: Buffer, lastFrame: Buffer, prompt: string, options?: VideoTransitionOptions, region?: string): Promise<Buffer>;
+    /** Validate the provider is configured (auth, base URL, etc.). */
+    isConfigured(): boolean;
+    /** Maximum video duration in seconds supported by this provider. */
+    readonly maxDurationSeconds?: number;
+    /** Supported aspect ratios. */
+    readonly supportedAspectRatios?: readonly ("9:16" | "16:9" | "1:1" | "4:3" | "3:4")[];
+    /** Supported output resolutions. */
+    readonly supportedResolutions?: readonly ("480p" | "720p" | "1080p" | "4k")[];
+};
+/**
+ * Kling (PiAPI) task status response.
+ */
+export type KlingTaskResponse = {
+    status?: string;
+    video_url?: string;
+    output?: {
+        video_url?: string;
+    };
+    error?: string;
+};
+/**
+ * Runway task status response.
+ */
+export type RunwayTaskResponse = {
+    status?: string;
+    output?: string[] | string;
+    error?: string;
+    failure?: string;
+};

package/dist/lib/types/video.js

@@ -0,0 +1,15 @@
+/**
+ * Video Generation Type Definitions
+ *
+ * Shared types for video generation across providers (Vertex Veo, Kling,
+ * Runway, Replicate-hosted models, etc.).
+ *
+ * The shared base shapes (`VideoOutputOptions`, `VideoGenerationResult`)
+ * are defined in `multimodal.ts` for backwards compatibility — they are
+ * re-exported here so callers can import every video-related type from a
+ * single module.
+ *
+ * @module types/video
+ */
+export {};
+//# sourceMappingURL=video.js.map

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

@@ -0,0 +1,68 @@
+/**
+ * Avatar / Lip-sync Generation Processing Utility
+ *
+ * Central registry + dispatch for avatar handlers across providers
+ * (D-ID, HeyGen, Replicate-hosted MuseTalk / SadTalker / Wav2Lip).
+ *
+ * Mirrors the static-handler-registry pattern established by
+ * `TTSProcessor` / `STTProcessor` / `VideoProcessor` / `MusicProcessor`.
+ *
+ * @module utils/avatarProcessor
+ */
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
+import type { AvatarHandler, AvatarOptions, AvatarResult } from "../types/index.js";
+import { NeuroLinkError } from "./errorHandling.js";
+/**
+ * Avatar-specific error codes.
+ */
+export declare const AVATAR_ERROR_CODES: {
+    readonly PROVIDER_NOT_SUPPORTED: "AVATAR_PROVIDER_NOT_SUPPORTED";
+    readonly PROVIDER_NOT_CONFIGURED: "AVATAR_PROVIDER_NOT_CONFIGURED";
+    readonly GENERATION_FAILED: "AVATAR_GENERATION_FAILED";
+    readonly POLL_TIMEOUT: "AVATAR_POLL_TIMEOUT";
+    readonly INVALID_INPUT: "AVATAR_INVALID_INPUT";
+    readonly AUDIO_REQUIRED: "AVATAR_AUDIO_REQUIRED";
+    readonly IMAGE_REQUIRED: "AVATAR_IMAGE_REQUIRED";
+    readonly AUDIO_TOO_LONG: "AVATAR_AUDIO_TOO_LONG";
+};
+/**
+ * Typed error class for avatar-generation failures.
+ */
+export declare class AvatarError extends NeuroLinkError {
+    constructor(options: {
+        code: string;
+        message: string;
+        category?: ErrorCategory;
+        severity?: ErrorSeverity;
+        retriable?: boolean;
+        context?: Record<string, unknown>;
+        originalError?: Error;
+    });
+}
+/**
+ * Static processor managing the avatar handler registry.
+ */
+export declare class AvatarProcessor {
+    private static readonly handlers;
+    /**
+     * Register an avatar handler for a specific provider.
+     */
+    static registerHandler(providerName: string, handler: AvatarHandler): void;
+    /**
+     * Check if a provider has a registered avatar handler.
+     */
+    static supports(providerName: string): boolean;
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders(): string[];
+    private static getHandler;
+    private static buildSpanAttributes;
+    /**
+     * Generate an avatar video via the registered handler.
+     *
+     * @throws AvatarError on registry miss, handler-not-configured, or
+     *         generation failure.
+     */
+    static generate(provider: string, options: AvatarOptions): Promise<AvatarResult>;
+}