@juspay/neurolink 9.67.1 → 9.67.3

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

@@ -248,3 +248,23 @@ export type OpenAICompatBuildBodyArgs = {
     streaming: boolean;
     responseFormat?: OpenAICompatResponseFormat;
 };
+/**
+ * Per-stream lifecycle listeners returned from an OpenAIChatCompletionsProvider
+ * subclass's `onStreamStart` hook. Every property is optional — provide only
+ * what the subclass cares about. Used by LiteLLM to wire an OTel span around
+ * the deferred analytics promises.
+ */
+export type OpenAICompatStreamLifecycleListeners = {
+    /** Fired once the deferred usage promise resolves with the final aggregated token counts. */
+    onUsage?: (usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }) => void;
+    /**
+     * Fired once the deferred finish promise resolves. `reason` is "stop",
+     * "length", "tool-calls", "content-filter", or "error". When the loop
+     * errored, the upstream cause is passed as `capturedError`.
+     */
+    onFinish?: (reason: string, capturedError?: unknown) => void;
+};

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

@@ -903,6 +903,8 @@ export type AnthropicVertexSettings = {
     projectId: string;
     /** Google Cloud region for Anthropic models (e.g., 'us-east5') */
     region: string;
+    /** SDK request timeout in milliseconds */
+    timeout?: number;
 };
 /**
  * OpenAI-compatible models endpoint response structure

package/dist/providers/googleVertex.js

@@ -366,12 +366,13 @@ const createVertexSettings = async (region) => {
     return baseSettings;
 };
 // Create Anthropic-specific Vertex settings for native @anthropic-ai/vertex-sdk
-const createVertexAnthropicSettings = async (region) => {
+const createVertexAnthropicSettings = async (region, timeoutMs) => {
     const location = region || getVertexLocation();
     const project = getVertexProjectId();
     return {
         projectId: project,
         region: location,
+        ...(timeoutMs !== undefined && { timeout: timeoutMs }),
     };
 };
 // Helper function to determine if a model is an Anthropic model
@@ -2032,9 +2033,9 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * Create native AnthropicVertex client for Claude models
      */
-    async createAnthropicVertexClient() {
+    async createAnthropicVertexClient(timeoutMs) {
         const mod = await getAnthropicVertexModule();
-        const settings = await createVertexAnthropicSettings(this.location);
+        const settings = await createVertexAnthropicSettings(this.location, timeoutMs);
         return new mod.AnthropicVertex(settings);
     }
     /**
@@ -2042,9 +2043,10 @@ export class GoogleVertexProvider extends BaseProvider {
      * This bypasses @ai-sdk/google-vertex completely and uses Anthropic's native SDK
      */
     async executeNativeAnthropicStream(options) {
-        const client = await this.createAnthropicVertexClient();
         const modelName = options.model || this.modelName || "claude-sonnet-4-5@20250929";
         const startTime = Date.now();
+        const streamTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
+        const client = await this.createAnthropicVertexClient(streamTimeoutMs);
         logger.debug("[GoogleVertex] Using native @anthropic-ai/vertex-sdk for Claude stream", {
             model: modelName,
             project: this.projectId,
@@ -2336,7 +2338,6 @@ export class GoogleVertexProvider extends BaseProvider {
         // abort the stream after the configured timeout so a stalled
         // Vertex/Anthropic endpoint can't hang forever. options.timeout wins
         // if set; otherwise 5 min — generous for tool-heavy turns.
-        const streamTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
         const streamTimeoutHandle = setTimeout(() => {
             logger.warn(`[GoogleVertex] Anthropic stream exceeded ${streamTimeoutMs}ms — aborting`);
             abortHandler();
@@ -2560,9 +2561,10 @@ export class GoogleVertexProvider extends BaseProvider {
      * Execute generate using native @anthropic-ai/vertex-sdk for Claude models on Vertex AI
      */
     async executeNativeAnthropicGenerate(options) {
-        const client = await this.createAnthropicVertexClient();
         const modelName = options.model || this.modelName || "claude-sonnet-4-5@20250929";
         const startTime = Date.now();
+        const generateTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
+        const client = await this.createAnthropicVertexClient(generateTimeoutMs);
         logger.debug("[GoogleVertex] Using native @anthropic-ai/vertex-sdk for Claude generate", {
             model: modelName,
             project: this.projectId,
@@ -2826,7 +2828,6 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Bound the SDK wait so a stalled Vertex/Anthropic call can't hang
                 // generate forever. options.timeout wins if set, otherwise default
                 // to 5 min — generous for tool-heavy turns.
-                const generateTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
                 const response = await withTimeout(client.messages.create({
                     ...requestParams,
                     messages: currentMessages,

package/dist/providers/litellm.d.ts

@@ -1,15 +1,19 @@
-import type { ZodType } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * LiteLLM Provider - BaseProvider Implementation
- * Provides access to 100+ models via LiteLLM proxy server
+ * LiteLLM Provider — direct HTTP, no AI SDK. Talks to a LiteLLM proxy
+ * server (or any deployment that speaks OpenAI chat-completions + the
+ * `/v1/models` and `/v1/embeddings` endpoints).
+ *
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`. This class adds LiteLLM-specific
+ * behaviour: OTel span wrap with cost (`onStreamStart`), Gemini 2.5
+ * maxTokens skip (`adjustBuildBodyOptions`), ModelAccessDeniedError on
+ * 403, 10-minute model cache (`getAvailableModels`), `LITELLM_FALLBACK_MODELS`
+ * env-driven fallback list, and native `/v1/embeddings`.
  */
-export declare class LiteLLMProvider extends BaseProvider {
-    private model;
-    private credentials?;
+export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly MODELS_CACHE_DURATION;
@@ -19,39 +23,35 @@ export declare class LiteLLMProvider extends BaseProvider {
     });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
+    protected getFallbackModelName(): string;
+    protected getFallbackModels(): string[];
     /**
-     * Returns the Vercel AI SDK model instance for LiteLLM
+     * Gemini 2.5 models on LiteLLM have a known compatibility issue with
+     * `max_tokens` — strip it before the wire body is built. Applies to
+     * both streaming and non-streaming paths.
      */
-    protected getAISDKModel(): LanguageModel;
-    formatProviderError(error: unknown): Error;
+    protected adjustBuildBodyOptions(modelId: string, opts: OpenAICompatBuildBodyArgs["options"]): OpenAICompatBuildBodyArgs["options"];
     /**
-     * LiteLLM supports tools for compatible models
+     * Wrap the stream in an OTel span to capture provider-level latency,
+     * token usage, finish reason, and cost. Matches the pre-migration
+     * behaviour where streamText was wrapped in `neurolink.provider.streamText`.
      */
-    supportsTools(): boolean;
+    protected onStreamStart(modelId: string): OpenAICompatStreamLifecycleListeners | undefined;
+    formatProviderError(error: unknown): Error;
     /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
+     * Get available models from LiteLLM proxy `/v1/models` endpoint.
+     * Caches results for 10 minutes; falls back to env-driven list or a
+     * minimal safe default if the API fetch fails.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
-    private createLiteLLMTransformedStream;
+    getAvailableModels(): Promise<string[]>;
+    private fetchModelsFromAPI;
     /**
-     * Generate an embedding for a single text input
-     * Uses the LiteLLM proxy with OpenAI-compatible embedding API
+     * Generate an embedding for a single text input via native /v1/embeddings.
      */
     embed(text: string, modelName?: string): Promise<number[]>;
     /**
-     * Generate embeddings for multiple text inputs
-     * Uses the LiteLLM proxy with OpenAI-compatible embedding API
+     * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
-    /**
-     * Get available models from LiteLLM proxy server
-     * Dynamically fetches from /v1/models endpoint with caching and fallback
-     */
-    getAvailableModels(): Promise<string[]>;
-    /**
-     * Fetch available models from LiteLLM proxy /v1/models endpoint
-     * @private
-     */
-    private fetchModelsFromAPI;
+    private callEmbeddings;
 }