@juspay/neurolink 7.32.0 → 7.33.1

package/dist/lib/core/baseProvider.d.ts

@@ -1,6 +1,6 @@
 import type { ValidationSchema } from "../types/typeAliases.js";
 import type { Tool, LanguageModelV1 } from "ai";
-import type { AIProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../types/index.js";
 import type { EvaluationData } from "../index.js";
 import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
@@ -37,6 +37,8 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, _analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     /**
@@ -110,6 +112,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * MCP tools are added when available (without blocking)
      */
     protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    private calculateActualCost;
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/lib/core/baseProvider.js

@@ -10,6 +10,7 @@ import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
 import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
 import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "./evaluationProviders.js";
 import { modelConfig } from "./modelConfiguration.js";
+// Provider types moved to ../types/providers.js
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -146,6 +147,8 @@ export class BaseProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     async generate(optionsOrPrompt, _analysisSchema) {
         const options = this.normalizeTextOptions(optionsOrPrompt);
@@ -153,8 +156,9 @@ export class BaseProvider {
         this.validateOptions(options);
         const startTime = Date.now();
         try {
-            // Import generateText dynamically to avoid circular dependencies
-            const { generateText } = await import("ai");
+            // Import streamText dynamically to avoid circular dependencies
+            // Using streamText instead of generateText for unified implementation
+            const { streamText } = await import("ai");
             // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const baseTools = shouldUseTools ? await this.getAllTools() : {};
@@ -175,7 +179,8 @@ export class BaseProvider {
             const model = await this.getAISDKModelWithMiddleware(options);
             // Build proper message array with conversation history
             const messages = buildMessagesArray(options);
-            const result = await generateText({
+            // Use streamText and accumulate results instead of generateText
+            const streamResult = await streamText({
                 model,
                 messages: messages,
                 tools,
@@ -184,31 +189,30 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            // Accumulate the streamed content
+            let accumulatedContent = "";
+            // Wait for the stream to complete and accumulate content
+            for await (const chunk of streamResult.textStream) {
+                accumulatedContent += chunk;
+            }
+            // Get the final result - this should include usage, toolCalls, etc.
+            const usage = await streamResult.usage;
+            const toolCalls = await streamResult.toolCalls;
+            const toolResults = await streamResult.toolResults;
             const responseTime = Date.now() - startTime;
+            // Create a result object compatible with generateText format
+            const result = {
+                text: accumulatedContent,
+                usage: usage,
+                toolCalls: toolCalls,
+                toolResults: toolResults,
+                steps: streamResult.steps, // Include steps for tool execution tracking
+            };
             try {
-                // Calculate actual cost based on token usage and provider configuration
-                const calculateActualCost = () => {
-                    try {
-                        const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
-                        if (!costInfo) {
-                            return 0; // No cost info available
-                        }
-                        const promptTokens = result.usage?.promptTokens || 0;
-                        const completionTokens = result.usage?.completionTokens || 0;
-                        // Calculate cost per 1K tokens
-                        const inputCost = (promptTokens / 1000) * costInfo.input;
-                        const outputCost = (completionTokens / 1000) * costInfo.output;
-                        return inputCost + outputCost;
-                    }
-                    catch (error) {
-                        logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
-                        return 0; // Fallback to 0 on any error
-                    }
-                };
-                const actualCost = calculateActualCost();
+                const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
                 recordProviderPerformanceFromMetrics(this.providerName, {
                     responseTime,
-                    tokensGenerated: result.usage?.totalTokens || 0,
+                    tokensGenerated: usage?.totalTokens || 0,
                     cost: actualCost,
                     success: true,
                 });
@@ -216,7 +220,7 @@ export class BaseProvider {
                 const optimizedProvider = getPerformanceOptimizedProvider("speed");
                 logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
                     responseTime: `${responseTime}ms`,
-                    tokens: result.usage?.totalTokens || 0,
+                    tokens: usage?.totalTokens || 0,
                     estimatedCost: `$${actualCost.toFixed(6)}`,
                     recommendedSpeedProvider: optimizedProvider?.provider || "none",
                 });
@@ -228,11 +232,9 @@ export class BaseProvider {
             // AI SDK puts tool calls in steps array for multi-step generation
             const toolsUsed = [];
             // First check direct tool calls (fallback)
-            if (result.toolCalls && result.toolCalls.length > 0) {
-                toolsUsed.push(...result.toolCalls.map((tc) => {
-                    return (tc.toolName ||
-                        tc.name ||
-                        "unknown");
+            if (toolCalls && toolCalls.length > 0) {
+                toolsUsed.push(...toolCalls.map((tc) => {
+                    return tc.toolName || "unknown";
                 }));
             }
             // Then check steps for tool calls (primary source for multi-step)
@@ -326,20 +328,14 @@ export class BaseProvider {
                 },
                 provider: this.providerName,
                 model: this.modelName,
-                toolCalls: result.toolCalls
-                    ? result.toolCalls.map((tc) => ({
-                        toolCallId: tc.toolCallId ||
-                            tc.id ||
-                            "unknown",
-                        toolName: tc.toolName ||
-                            tc.name ||
-                            "unknown",
-                        args: tc.args ||
-                            tc.parameters ||
-                            {},
+                toolCalls: toolCalls
+                    ? toolCalls.map((tc) => ({
+                        toolCallId: tc.toolCallId || "unknown",
+                        toolName: tc.toolName || "unknown",
+                        args: tc.args || {},
                     }))
                     : [],
-                toolResults: result.toolResults,
+                toolResults: toolResults || [],
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
                 availableTools: Object.keys(tools).map((name) => {
@@ -655,6 +651,27 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${getKeysAsString(tools)}`);
         return tools;
     }
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    async calculateActualCost(usage) {
+        try {
+            const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
+            if (!costInfo) {
+                return 0; // No cost info available
+            }
+            const promptTokens = usage?.promptTokens || 0;
+            const completionTokens = usage?.completionTokens || 0;
+            // Calculate cost per 1K tokens
+            const inputCost = (promptTokens / 1000) * costInfo.input;
+            const outputCost = (completionTokens / 1000) * costInfo.output;
+            return inputCost + outputCost;
+        }
+        catch (error) {
+            logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
+            return 0; // Fallback to 0 on any error
+        }
+    }
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/lib/core/dynamicModels.d.ts

@@ -1,129 +1,4 @@
-import { z } from "zod";
-/**
- * Model configuration schema for validation
- */
-declare const ModelConfigSchema: z.ZodObject<{
-    id: z.ZodString;
-    displayName: z.ZodString;
-    capabilities: z.ZodArray<z.ZodString, "many">;
-    deprecated: z.ZodBoolean;
-    pricing: z.ZodObject<{
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        input: number;
-        output: number;
-    }, {
-        input: number;
-        output: number;
-    }>;
-    contextWindow: z.ZodNumber;
-    releaseDate: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    capabilities: string[];
-    displayName: string;
-    deprecated: boolean;
-    pricing: {
-        input: number;
-        output: number;
-    };
-    contextWindow: number;
-    releaseDate: string;
-}, {
-    id: string;
-    capabilities: string[];
-    displayName: string;
-    deprecated: boolean;
-    pricing: {
-        input: number;
-        output: number;
-    };
-    contextWindow: number;
-    releaseDate: string;
-}>;
-declare const ModelRegistrySchema: z.ZodObject<{
-    version: z.ZodString;
-    lastUpdated: z.ZodString;
-    models: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-        capabilities: z.ZodArray<z.ZodString, "many">;
-        deprecated: z.ZodBoolean;
-        pricing: z.ZodObject<{
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            input: number;
-            output: number;
-        }, {
-            input: number;
-            output: number;
-        }>;
-        contextWindow: z.ZodNumber;
-        releaseDate: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        capabilities: string[];
-        displayName: string;
-        deprecated: boolean;
-        pricing: {
-            input: number;
-            output: number;
-        };
-        contextWindow: number;
-        releaseDate: string;
-    }, {
-        id: string;
-        capabilities: string[];
-        displayName: string;
-        deprecated: boolean;
-        pricing: {
-            input: number;
-            output: number;
-        };
-        contextWindow: number;
-        releaseDate: string;
-    }>>>;
-    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    models: Record<string, Record<string, {
-        id: string;
-        capabilities: string[];
-        displayName: string;
-        deprecated: boolean;
-        pricing: {
-            input: number;
-            output: number;
-        };
-        contextWindow: number;
-        releaseDate: string;
-    }>>;
-    version: string;
-    lastUpdated: string;
-    defaults?: Record<string, string> | undefined;
-    aliases?: Record<string, string> | undefined;
-}, {
-    models: Record<string, Record<string, {
-        id: string;
-        capabilities: string[];
-        displayName: string;
-        deprecated: boolean;
-        pricing: {
-            input: number;
-            output: number;
-        };
-        contextWindow: number;
-        releaseDate: string;
-    }>>;
-    version: string;
-    lastUpdated: string;
-    defaults?: Record<string, string> | undefined;
-    aliases?: Record<string, string> | undefined;
-}>;
-export type ModelConfig = z.infer<typeof ModelConfigSchema>;
-export type ModelRegistry = z.infer<typeof ModelRegistrySchema>;
+import type { DynamicModelConfig as ModelConfig } from "../types/index.js";
 /**
  * Dynamic Model Provider
  * Loads and manages model configurations from external sources
@@ -150,11 +25,6 @@ export declare class DynamicModelProvider {
      * Prevents hanging on non-responsive local servers
      */
     private healthCheckLocalhost;
-    /**
-     * Load configuration from a source (URL or file path) - Legacy method for compatibility
-     * @deprecated Use loadFromSourceWithTimeout instead
-     */
-    private loadFromSource;
     /**
      * Get all available models for a provider
      */
@@ -217,4 +87,3 @@ export declare class DynamicModelProvider {
     } | null;
 }
 export declare const dynamicModelProvider: DynamicModelProvider;
-export {};

package/dist/lib/core/dynamicModels.js

@@ -190,13 +190,6 @@ export class DynamicModelProvider {
             });
         }
     }
-    /**
-     * Load configuration from a source (URL or file path) - Legacy method for compatibility
-     * @deprecated Use loadFromSourceWithTimeout instead
-     */
-    async loadFromSource(source) {
-        return this.loadFromSourceWithTimeout(source, 10000); // 10s default timeout
-    }
     /**
      * Get all available models for a provider
      */

package/dist/lib/core/evaluation.d.ts

@@ -1,45 +1,7 @@
 /**
  * NeuroLink Evaluation System
  */
-import type { EvaluationData } from "../index.js";
-export interface EvaluationResult extends EvaluationData {
-    domainAlignment?: number;
-    terminologyAccuracy?: number;
-    toolEffectiveness?: number;
-    contextUtilization?: {
-        conversationUsed: boolean;
-        toolsUsed: boolean;
-        domainKnowledgeUsed: boolean;
-    };
-    evaluationContext?: {
-        domain: string;
-        toolsEvaluated: string[];
-        conversationTurns: number;
-    };
-    isOffTopic: boolean;
-    alertSeverity: "low" | "medium" | "high" | "none";
-    reasoning: string;
-}
-export interface EvaluationContext {
-    userQuery: string;
-    aiResponse: string;
-    context?: Record<string, unknown>;
-    primaryDomain?: string;
-    assistantRole?: string;
-    conversationHistory?: Array<{
-        role: "user" | "assistant";
-        content: string;
-        timestamp?: string;
-    }>;
-    toolUsage?: Array<{
-        toolName: string;
-        input: unknown;
-        output: unknown;
-        executionTime: number;
-    }>;
-    expectedOutcome?: string;
-    evaluationCriteria?: string[];
-}
+import type { EnhancedEvaluationResult as EvaluationResult, EvaluationContext } from "../types/index.js";
 /**
  * Get default evaluation when evaluation fails
  */

package/dist/lib/core/evaluationProviders.d.ts

@@ -1,19 +1,4 @@
-interface ProviderModelConfig {
-    provider: string;
-    models: string[];
-    costPerToken?: number | {
-        input: number;
-        output: number;
-    };
-    requiresApiKey?: string[];
-    performance?: {
-        averageLatency?: number;
-        reliability?: number;
-        speed?: number;
-        quality?: number;
-        cost?: number;
-    };
-}
+import type { ProviderModelConfig } from "../types/index.js";
 /**
  * Dynamic provider configurations for evaluation
  * Now uses configurable system instead of hardcoded values
@@ -73,4 +58,3 @@ export declare function getProviderPerformanceAnalytics(): Record<string, {
  * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
  */
 export declare function resetProviderMetrics(providerName?: string): void;
-export {};

package/dist/lib/core/evaluationProviders.js

@@ -40,7 +40,7 @@ export const EVALUATION_PROVIDER_CONFIGS = getEvaluationProviderConfigs();
  * Now uses the configurable system
  */
 export function getProviderConfig(providerName) {
-    const config = modelConfig.getProviderConfig(providerName);
+    const config = modelConfig.getProviderConfiguration(providerName);
     return config ? convertToLegacyFormat(config) : null;
 }
 /**

package/dist/lib/core/factory.d.ts

@@ -1,7 +1,6 @@
-import type { AIProvider, AIProviderName, SupportedModelName } from "./types.js";
+import type { AIProvider, AIProviderName, SupportedModelName } from "../types/index.js";
 import type { UnknownRecord } from "../types/common.js";
 import type { ProviderPairResult } from "../types/typeAliases.js";
-declare const componentIdentifier = "aiProviderFactory";
 /**
  * Factory for creating AI provider instances with centralized configuration
  */
@@ -48,4 +47,3 @@ export declare class AIProviderFactory {
      */
     static createProviderWithFallback(primaryProvider: string, fallbackProvider: string, modelName?: string | null, enableMCP?: boolean): Promise<ProviderPairResult<AIProvider>>;
 }
-export { componentIdentifier };

package/dist/lib/core/factory.js

@@ -316,4 +316,3 @@ export class AIProviderFactory {
         }
     }
 }
-export { componentIdentifier };

package/dist/lib/core/modelConfiguration.d.ts

@@ -4,7 +4,7 @@
  * Replaces hardcoded model-specific logic with configurable, runtime-updateable configurations.
  * This addresses GitHub Copilot review comment about making model-specific logic configuration-based.
  */
-import type { JsonValue } from "../types/common.js";
+import type { ModelTier, ProviderConfiguration, ConfigSource } from "../types/modelTypes.js";
 /**
  * Model name constants - extracted from hardcoded values for better maintainability
  * These constants can be overridden by environment variables
@@ -61,67 +61,6 @@ export declare const MODEL_NAMES: {
         readonly QUALITY: "mistral-large-latest";
     };
 };
-/**
- * Model performance tier definition
- */
-export type ModelTier = "fast" | "balanced" | "quality";
-/**
- * Model configuration for a specific provider
- */
-export interface ModelConfig {
-    /** Model identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Performance tier */
-    tier: ModelTier;
-    /** Cost per 1K tokens */
-    cost: {
-        input: number;
-        output: number;
-    };
-    /** Model capabilities */
-    capabilities: string[];
-    /** Model-specific options */
-    options?: Record<string, JsonValue>;
-}
-/**
- * Provider configuration with models
- */
-export interface ProviderConfig {
-    /** Provider name */
-    provider: string;
-    /** Available models by tier */
-    models: Record<ModelTier, string>;
-    /** Default cost per token (fallback) */
-    defaultCost: {
-        input: number;
-        output: number;
-    };
-    /** Required environment variables */
-    requiredEnvVars: string[];
-    /** Provider-specific performance metrics */
-    performance: {
-        speed: number;
-        quality: number;
-        cost: number;
-    };
-    /** Provider-specific model configurations */
-    modelConfigs?: Record<string, ModelConfig>;
-    /** Provider-specific model behavior configurations */
-    modelBehavior?: {
-        /** Models that have issues with maxTokens parameter */
-        maxTokensIssues?: string[];
-        /** Models that require special handling */
-        specialHandling?: Record<string, JsonValue>;
-        /** Models that support tool calling (Ollama-specific) */
-        toolCapableModels?: string[];
-    };
-}
-/**
- * Configuration source type
- */
-export type ConfigSource = "default" | "environment" | "file" | "dynamic";
 /**
  * Model configuration manager
  */
@@ -147,7 +86,7 @@ export declare class ModelConfigurationManager {
     /**
      * Create all provider configurations - centralized approach
      */
-    private createAllProviderConfigs;
+    private createAllProviderConfigurations;
     /**
      * Create Anthropic provider configuration
      */
@@ -209,15 +148,15 @@ export declare class ModelConfigurationManager {
     /**
      * Get provider configuration
      */
-    getProviderConfig(provider: string): ProviderConfig | null;
+    getProviderConfiguration(provider: string): ProviderConfiguration | null;
     /**
      * Get all provider configurations
      */
-    getAllConfigurations(): Map<string, ProviderConfig>;
+    getAllConfigurations(): Map<string, ProviderConfiguration>;
     /**
      * Update provider configuration (runtime updates)
      */
-    updateProviderConfig(provider: string, config: ProviderConfig): void;
+    updateProviderConfiguration(provider: string, config: ProviderConfiguration): void;
     /**
      * Parse YAML content with basic support
      * For full YAML support, would need a proper YAML library
@@ -244,7 +183,7 @@ export declare class ModelConfigurationManager {
     /**
      * Validate provider configuration structure
      */
-    private isValidProviderConfig;
+    private isValidProviderConfiguration;
     /**
      * Apply model name overrides from configuration file
      */
@@ -279,7 +218,7 @@ export declare class ModelConfigurationManager {
     /**
      * Get available providers
      */
-    getAvailableProviders(): ProviderConfig[];
+    getAvailableProviders(): ProviderConfiguration[];
 }
 /**
  * Global instance accessor
@@ -291,7 +230,7 @@ export declare const modelConfig: ModelConfigurationManager;
 /**
  * Get provider configuration (backwards compatible)
  */
-export declare function getProviderConfig(provider: string): ProviderConfig | null;
+export declare function getProviderConfiguration(provider: string): ProviderConfiguration | null;
 /**
  * Get model for tier (backwards compatible)
  */

package/dist/lib/core/modelConfiguration.js

@@ -175,7 +175,7 @@ export class ModelConfigurationManager {
     /**
      * Create all provider configurations - centralized approach
      */
-    createAllProviderConfigs() {
+    createAllProviderConfigurations() {
         return {
             "google-ai": this.createGoogleAIConfig(),
             "google-vertex": this.createVertexConfig(),
@@ -383,7 +383,7 @@ export class ModelConfigurationManager {
      */
     loadDefaultConfigurations() {
         // Load all provider configurations using centralized method
-        const defaultConfigs = this.createAllProviderConfigs();
+        const defaultConfigs = this.createAllProviderConfigurations();
         // Load configurations
         for (const [provider, config] of Object.entries(defaultConfigs)) {
             this.configurations.set(provider, config);
@@ -484,7 +484,7 @@ export class ModelConfigurationManager {
     /**
      * Get provider configuration
      */
-    getProviderConfig(provider) {
+    getProviderConfiguration(provider) {
         return this.configurations.get(provider) || null;
     }
     /**
@@ -496,7 +496,7 @@ export class ModelConfigurationManager {
     /**
      * Update provider configuration (runtime updates)
      */
-    updateProviderConfig(provider, config) {
+    updateProviderConfiguration(provider, config) {
         this.configurations.set(provider, config);
         this.lastUpdated = Date.now();
         this.configSource = "dynamic";
@@ -596,7 +596,7 @@ export class ModelConfigurationManager {
             if (config.providers && typeof config.providers === "object") {
                 const providers = config.providers;
                 for (const [providerName, providerConfig] of Object.entries(providers)) {
-                    if (this.isValidProviderConfig(providerConfig)) {
+                    if (this.isValidProviderConfiguration(providerConfig)) {
                         this.configurations.set(providerName, providerConfig);
                         logger.debug(`Loaded configuration for provider: ${providerName}`);
                     }
@@ -629,7 +629,7 @@ export class ModelConfigurationManager {
     /**
      * Validate provider configuration structure
      */
-    isValidProviderConfig(config) {
+    isValidProviderConfiguration(config) {
         if (!config || typeof config !== "object") {
             return false;
         }
@@ -769,14 +769,14 @@ export class ModelConfigurationManager {
      * Get model for specific tier and provider
      */
     getModelForTier(provider, tier) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         return config?.models[tier] || null;
     }
     /**
      * Get cost information for provider and model
      */
     getCostInfo(provider, model) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         if (!config) {
             return null;
         }
@@ -790,7 +790,7 @@ export class ModelConfigurationManager {
      * Check if provider is available (has required environment variables)
      */
     isProviderAvailable(provider) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         if (!config) {
             return false;
         }
@@ -816,8 +816,8 @@ export const modelConfig = ModelConfigurationManager.getInstance();
 /**
  * Get provider configuration (backwards compatible)
  */
-export function getProviderConfig(provider) {
-    return modelConfig.getProviderConfig(provider);
+export function getProviderConfiguration(provider) {
+    return modelConfig.getProviderConfiguration(provider);
 }
 /**
  * Get model for tier (backwards compatible)