@juspay/neurolink 9.67.0 → 9.67.2

package/dist/lib/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/lib/providers/litellm.d.ts

@@ -1,15 +1,15 @@
-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 { LanguageModel, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.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).
  */
 export declare class LiteLLMProvider extends BaseProvider {
-    private model;
+    private config;
     private credentials?;
+    private resolvedModel?;
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly MODELS_CACHE_DURATION;
@@ -20,38 +20,45 @@ export declare class LiteLLMProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
-     * Returns the Vercel AI SDK model instance for LiteLLM
+     * Abstract from BaseProvider — used by the parent's generate() path which
+     * still goes through `generateText`. Returns a thin LanguageModelV3-shaped
+     * object that delegates to the same HTTP helpers used by executeStream.
      */
-    protected getAISDKModel(): LanguageModel;
-    formatProviderError(error: unknown): Error;
+    protected getAISDKModel(): Promise<LanguageModel>;
+    private resolveModelName;
     /**
-     * LiteLLM supports tools for compatible models
+     * Returns a minimal V3-shaped model. Only used by BaseProvider's
+     * `generate()` non-streaming path which still relies on the parent's
+     * `generateText`. The streaming path bypasses this entirely.
      */
+    private buildDelegatingModel;
+    formatProviderError(error: unknown): Error;
     supportsTools(): boolean;
     /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
+     * Streaming path — drives the LiteLLM proxy directly. No streamText, no
+     * AI SDK orchestrator. Tool calls, multi-step loops, telemetry, abort
+     * handling all inline. OTel span captures gen_ai.system + cost.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
-    private createLiteLLMTransformedStream;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
+    private runStreamLoop;
+    private streamOneStep;
+    private executeToolBatch;
     /**
-     * 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[][]>;
+    private callEmbeddings;
     /**
-     * Get available models from LiteLLM proxy server
-     * Dynamically fetches from /v1/models endpoint with caching and fallback
+     * 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.
      */
     getAvailableModels(): Promise<string[]>;
-    /**
-     * Fetch available models from LiteLLM proxy /v1/models endpoint
-     * @private
-     */
+    getFirstAvailableModel(): Promise<string>;
+    private getFallbackModels;
     private fetchModelsFromAPI;
 }