@juspay/neurolink 10.12.8 → 11.0.0

package/dist/lib/core/modelConfiguration.js

@@ -5,8 +5,6 @@
  * This addresses GitHub Copilot review comment about making model-specific logic configuration-based.
  */
 import { logger } from "../utils/logger.js";
-import fs from "fs";
-import path from "path";
 /**
  * Model name constants - extracted from hardcoded values for better maintainability
  * These constants can be overridden by environment variables
@@ -503,280 +501,6 @@ export class ModelConfigurationManager {
     getAllConfigurations() {
         return new Map(this.configurations);
     }
-    /**
-     * Update provider configuration (runtime updates)
-     */
-    updateProviderConfiguration(provider, config) {
-        this.configurations.set(provider, config);
-        this.lastUpdated = Date.now();
-        this.configSource = "dynamic";
-        logger.debug(`Updated configuration for provider: ${provider}`);
-    }
-    /**
-     * Parse YAML content with basic support
-     * For full YAML support, would need a proper YAML library
-     */
-    parseYAMLContent(configContent) {
-        // Basic YAML parsing for simple configurations
-        try {
-            return JSON.parse(configContent);
-        }
-        catch {
-            return this.convertSimpleYAMLToJSON(configContent);
-        }
-    }
-    /**
-     * Convert simple YAML to JSON object
-     * Handles basic key-value pairs only
-     */
-    convertSimpleYAMLToJSON(configContent) {
-        const yamlLines = configContent.split("\n");
-        const jsonObj = {};
-        for (const line of yamlLines) {
-            const processedLine = this.processYAMLLine(line);
-            if (processedLine) {
-                jsonObj[processedLine.key] = processedLine.value;
-            }
-        }
-        return jsonObj;
-    }
-    /**
-     * Process a single YAML line
-     * Returns key-value pair if valid, null otherwise
-     */
-    processYAMLLine(line) {
-        const trimmedLine = line.trim();
-        if (!trimmedLine || trimmedLine.startsWith("#")) {
-            return null;
-        }
-        const colonIndex = trimmedLine.indexOf(":");
-        if (colonIndex <= 0) {
-            return null;
-        }
-        const key = trimmedLine.substring(0, colonIndex).trim();
-        const value = trimmedLine.substring(colonIndex + 1).trim();
-        return {
-            key,
-            value: this.convertYAMLValue(value),
-        };
-    }
-    /**
-     * Convert YAML value to appropriate JavaScript type
-     */
-    convertYAMLValue(value) {
-        if (value === "true") {
-            return true;
-        }
-        if (value === "false") {
-            return false;
-        }
-        if (!isNaN(Number(value))) {
-            return Number(value);
-        }
-        return value.replace(/['"]/g, "");
-    }
-    /**
-     * Load configurations from external source
-     */
-    loadConfigurationsFromFile(configPath) {
-        try {
-            // Check if file exists
-            if (!fs.existsSync(configPath)) {
-                throw new Error(`Configuration file not found: ${configPath}`);
-            }
-            // Read and parse configuration file
-            const configContent = fs.readFileSync(configPath, "utf8");
-            const fileExtension = path.extname(configPath).toLowerCase();
-            let configData;
-            if (fileExtension === ".json") {
-                configData = JSON.parse(configContent);
-            }
-            else if (fileExtension === ".yaml" || fileExtension === ".yml") {
-                configData = this.parseYAMLContent(configContent);
-            }
-            else {
-                throw new Error(`Unsupported configuration file format: ${fileExtension}. Supported formats: .json, .yaml, .yml`);
-            }
-            // Validate configuration structure
-            if (!configData || typeof configData !== "object") {
-                throw new Error("Invalid configuration format: must be an object");
-            }
-            const config = configData;
-            // Load provider configurations from file
-            if (config.providers && typeof config.providers === "object") {
-                const providers = config.providers;
-                for (const [providerName, providerConfig] of Object.entries(providers)) {
-                    if (this.isValidProviderConfiguration(providerConfig)) {
-                        this.configurations.set(providerName, providerConfig);
-                        logger.debug(`Loaded configuration for provider: ${providerName}`);
-                    }
-                    else {
-                        logger.warn(`Invalid configuration for provider: ${providerName}, skipping`);
-                    }
-                }
-            }
-            // Load global model name overrides
-            if (config.modelNames && typeof config.modelNames === "object") {
-                const modelNames = config.modelNames;
-                this.applyModelNameOverrides(modelNames);
-            }
-            // Load global defaults
-            if (config.defaults && typeof config.defaults === "object") {
-                const defaults = config.defaults;
-                this.applyGlobalDefaults(defaults);
-            }
-            this.configSource = "file";
-            this.lastUpdated = Date.now();
-            logger.info(`Successfully loaded configurations from file: ${configPath}`);
-            logger.debug(`Loaded ${this.configurations.size} provider configurations`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to load configurations from file: ${errorMessage}`);
-            throw new Error(`Configuration loading failed: ${errorMessage}`, {
-                cause: error,
-            });
-        }
-    }
-    /**
-     * Validate provider configuration structure
-     */
-    isValidProviderConfiguration(config) {
-        if (!config || typeof config !== "object") {
-            return false;
-        }
-        const providerConfig = config;
-        // Check required fields
-        const requiredFields = [
-            "provider",
-            "models",
-            "defaultCost",
-            "requiredEnvVars",
-            "performance",
-        ];
-        for (const field of requiredFields) {
-            if (!(field in providerConfig)) {
-                return false;
-            }
-        }
-        // Validate models structure
-        if (typeof providerConfig.models !== "object" || !providerConfig.models) {
-            return false;
-        }
-        const models = providerConfig.models;
-        const requiredTiers = ["fast", "balanced", "quality"];
-        for (const tier of requiredTiers) {
-            if (typeof models[tier] !== "string") {
-                return false;
-            }
-        }
-        // Validate defaultCost structure
-        if (typeof providerConfig.defaultCost !== "object" ||
-            !providerConfig.defaultCost) {
-            return false;
-        }
-        const defaultCost = providerConfig.defaultCost;
-        if (typeof defaultCost.input !== "number" ||
-            typeof defaultCost.output !== "number") {
-            return false;
-        }
-        // Validate requiredEnvVars
-        if (!Array.isArray(providerConfig.requiredEnvVars)) {
-            return false;
-        }
-        // Validate performance structure
-        if (typeof providerConfig.performance !== "object" ||
-            !providerConfig.performance) {
-            return false;
-        }
-        const performance = providerConfig.performance;
-        const perfFields = ["speed", "quality", "cost"];
-        for (const field of perfFields) {
-            if (typeof performance[field] !== "number") {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Apply model name overrides from configuration file
-     */
-    applyModelNameOverrides(modelNames) {
-        try {
-            // Apply overrides to existing configurations
-            for (const [providerKey, providerModels] of Object.entries(modelNames)) {
-                if (typeof providerModels === "object" && providerModels) {
-                    const models = providerModels;
-                    const existingConfig = this.configurations.get(providerKey);
-                    if (existingConfig) {
-                        // Update existing configuration
-                        for (const [tier, model] of Object.entries(models)) {
-                            if (typeof model === "string" &&
-                                ["fast", "balanced", "quality"].includes(tier)) {
-                                existingConfig.models[tier] = model;
-                            }
-                        }
-                        this.configurations.set(providerKey, existingConfig);
-                        logger.debug(`Applied model name overrides for provider: ${providerKey}`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger.warn(`Failed to apply model name overrides: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Apply global default configurations
-     */
-    applyGlobalDefaults(defaults) {
-        try {
-            // Apply global defaults to all existing configurations
-            for (const [providerName, config] of this.configurations.entries()) {
-                let updated = false;
-                // Apply default cost overrides
-                if (defaults.defaultCost && typeof defaults.defaultCost === "object") {
-                    const defaultCost = defaults.defaultCost;
-                    if (typeof defaultCost.input === "number") {
-                        config.defaultCost.input = defaultCost.input;
-                        updated = true;
-                    }
-                    if (typeof defaultCost.output === "number") {
-                        config.defaultCost.output = defaultCost.output;
-                        updated = true;
-                    }
-                }
-                // Apply performance overrides
-                if (defaults.performance && typeof defaults.performance === "object") {
-                    const performance = defaults.performance;
-                    ["speed", "quality", "cost"].forEach((field) => {
-                        if (typeof performance[field] === "number") {
-                            config.performance[field] =
-                                performance[field];
-                            updated = true;
-                        }
-                    });
-                }
-                if (updated) {
-                    this.configurations.set(providerName, config);
-                    logger.debug(`Applied global defaults to provider: ${providerName}`);
-                }
-            }
-        }
-        catch (error) {
-            logger.warn(`Failed to apply global defaults: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get configuration metadata
-     */
-    getConfigurationMeta() {
-        return {
-            source: this.configSource,
-            lastUpdated: this.lastUpdated,
-            providerCount: this.configurations.size,
-        };
-    }
     /**
      * Get model for specific tier and provider
      */
@@ -822,31 +546,4 @@ export class ModelConfigurationManager {
  * Global instance accessor
  */
 export const modelConfig = ModelConfigurationManager.getInstance();
-/**
- * Convenience functions for common operations
- */
-/**
- * Get provider configuration (backwards compatible)
- */
-export function getProviderConfiguration(provider) {
-    return modelConfig.getProviderConfiguration(provider);
-}
-/**
- * Get model for tier (backwards compatible)
- */
-export function getModelForTier(provider, tier) {
-    return modelConfig.getModelForTier(provider, tier);
-}
-/**
- * Get cost information (backwards compatible)
- */
-export function getCostInfo(provider, model) {
-    return modelConfig.getCostInfo(provider, model);
-}
-/**
- * Check provider availability (backwards compatible)
- */
-export function isProviderAvailable(provider) {
-    return modelConfig.isProviderAvailable(provider);
-}
 //# sourceMappingURL=modelConfiguration.js.map

package/dist/lib/core/modules/GenerationHandler.js

@@ -25,7 +25,7 @@ import { calculateCacheSavingsPercent, extractCacheCreationTokens, extractCacheR
 import { DEFAULT_MAX_STEPS, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../constants.js";
 import { createStepBudgetGuard, estimateFixedOverheadTokens, } from "../../context/stepBudgetGuard.js";
 import { isTemperatureDeprecatedError, isSchemaComplexityError, isToolsSchemaConflictError, isToolsSchemaExclusionInForce, } from "./structuredOutputPolicy.js";
-import { coerceJsonToSchema } from "../../utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../../utils/json/coerce.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { NoObjectGeneratedError } from "../../utils/generationErrors.js";
 import { Output, stepCountIs } from "../../utils/tool.js";
@@ -247,8 +247,8 @@ export class GenerationHandler {
         // JSON Schema to the provider instead: it appends an additive
         // `final_result` tool and returns the answer as that tool's arguments,
         // keeping the real tools callable. Bedrock is deliberately excluded — it
-        // runs on the third-party @ai-sdk/amazon-bedrock model, which has no such
-        // handling.
+        // talks to the raw AWS SDK directly, not an ai-sdk provider package, and
+        // has no such handling.
         const finalResultSchema = this.providerName === "anthropic" &&
             !!options.schema &&
             shouldUseTools &&
@@ -800,26 +800,35 @@ export class GenerationHandler {
                 }
                 return coerced.content;
             }
-            try {
-                const scalar = JSON.parse(strippedText);
-                if (scalar === "") {
+            const scalar = recoverScalarRoot(strippedText, options.schema);
+            switch (scalar.kind) {
+                case "empty":
                     // A JSON-encoded empty string is an EMPTY completion, not a
                     // recovered scalar — normalize to a true empty ('' content, no
                     // structuredData) so callers' empty-response handling fires
                     // instead of a literal '""' reaching the user.
                     logger.warn("[GenerationHandler] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: this.providerName, model: this.modelName });
                     return "";
-                }
-                if (scalar !== null && scalar !== undefined) {
-                    structuredData = scalar;
+                case "accepted":
+                    // A JSON scalar root is only real structured data when the caller's
+                    // schema actually accepts it. Under an OBJECT schema a recovered
+                    // string/number is the raw completion in disguise (the shape a
+                    // truncated response degrades to) — publishing it would hand the
+                    // caller a `structuredData` that violates the schema they passed.
+                    structuredData = scalar.value;
+                    return strippedText;
+                case "rejected":
+                    logger.warn("[GenerationHandler] recovered a JSON scalar the requested schema rejects; leaving structuredData unset", {
+                        provider: this.providerName,
+                        model: this.modelName,
+                        scalarType: typeof scalar.value,
+                    });
+                    return strippedText;
+                case "nullish":
+                case "not-json":
+                    logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
                     return strippedText;
-                }
-            }
-            catch {
-                // not JSON at all — fall through to raw text + WARN
             }
-            logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
-            return strippedText;
         };
         if (useStructuredOutput) {
             try {
@@ -834,7 +843,20 @@ export class GenerationHandler {
                 // (a string identical to the step text) and coerce it instead.
                 const rawTextEcho = typeof experimentalOutput === "string" &&
                     experimentalOutput === (generateResult.text ?? "");
-                if (experimentalOutput !== undefined && !rawTextEcho) {
+                // The equality check above only catches an EXACT echo. On a multi-step
+                // or truncated turn the echo can differ from `text` (a different step's
+                // text, a fence, trailing whitespace), and a raw string would then be
+                // published as `structuredData` under an object schema — the "returned
+                // a string instead of the schema object" failure. A string is trusted
+                // as structured output ONLY when the caller's schema accepts it
+                // (string-root schemas keep working); otherwise it is coerced like any
+                // other raw model text.
+                const untrustedStringOutput = typeof experimentalOutput === "string" &&
+                    !!options.schema &&
+                    !schemaAccepts(options.schema, experimentalOutput);
+                if (experimentalOutput !== undefined &&
+                    !rawTextEcho &&
+                    !untrustedStringOutput) {
                     // AI-SDK already parsed + schema-validated the object. Expose it
                     // directly and serialise canonically — no hand-parsing needed.
                     structuredData = experimentalOutput;

package/dist/lib/core/modules/structuredOutputPolicy.d.ts

@@ -29,8 +29,8 @@ export declare function isGeminiProvider(providerName: string, modelName: string
  * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
  * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
  * schema enforcement without giving up tool calling. "bedrock" has no such
- * handling (it runs on the third-party @ai-sdk/amazon-bedrock model) and still
- * falls back to text-mode coercion.
+ * handling (it talks to the raw AWS SDK directly, not an ai-sdk provider
+ * package) and still falls back to text-mode coercion.
  */
 export declare function isNativeAnthropicProvider(providerName: string): boolean;
 /**

package/dist/lib/core/modules/structuredOutputPolicy.js

@@ -39,8 +39,8 @@ export function isGeminiProvider(providerName, modelName) {
  * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
  * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
  * schema enforcement without giving up tool calling. "bedrock" has no such
- * handling (it runs on the third-party @ai-sdk/amazon-bedrock model) and still
- * falls back to text-mode coercion.
+ * handling (it talks to the raw AWS SDK directly, not an ai-sdk provider
+ * package) and still falls back to text-mode coercion.
  */
 export function isNativeAnthropicProvider(providerName) {
     return providerName === "anthropic" || providerName === "bedrock";

package/dist/lib/factories/providerFactory.d.ts

@@ -1,6 +1,21 @@
 import type { NeuroLink } from "../neurolink.js";
 import type { AIProviderName } from "../constants/enums.js";
 import type { AIProvider, NeurolinkCredentials, ProviderConstructor, ProviderRegistration } from "../types/index.js";
+/**
+ * Maps registered provider names to NeurolinkCredentials keys. Most names
+ * match (openai, anthropic, vertex, bedrock, etc.) but every kebab-case
+ * provider whose canonical credentials key is camelCase — or otherwise
+ * spelled differently — MUST be mapped here, otherwise per-call/instance
+ * credential overrides silently get dropped (createProvider() looks up
+ * credentials["lm-studio"], which is undefined, while the caller wrote
+ * credentials.lmStudio).
+ */
+export declare const CREDENTIAL_KEY_MAP: Record<string, string>;
+/**
+ * Resolve a registered provider name to its NeurolinkCredentials key.
+ * Falls back to the provider name itself when no remapping is needed.
+ */
+export declare function resolveCredentialKey(providerName: string): string;
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements

package/dist/lib/factories/providerFactory.js

@@ -1,6 +1,30 @@
 import { logger } from "../utils/logger.js";
 // Pure factory pattern with no hardcoded imports
 // All providers loaded dynamically via registry to avoid circular dependencies
+/**
+ * Maps registered provider names to NeurolinkCredentials keys. Most names
+ * match (openai, anthropic, vertex, bedrock, etc.) but every kebab-case
+ * provider whose canonical credentials key is camelCase — or otherwise
+ * spelled differently — MUST be mapped here, otherwise per-call/instance
+ * credential overrides silently get dropped (createProvider() looks up
+ * credentials["lm-studio"], which is undefined, while the caller wrote
+ * credentials.lmStudio).
+ */
+export const CREDENTIAL_KEY_MAP = {
+    "google-ai": "googleAiStudio",
+    "openai-compatible": "openaiCompatible",
+    huggingface: "huggingFace",
+    "lm-studio": "lmStudio",
+    "nvidia-nim": "nvidiaNim",
+    "together-ai": "together",
+};
+/**
+ * Resolve a registered provider name to its NeurolinkCredentials key.
+ * Falls back to the provider name itself when no remapping is needed.
+ */
+export function resolveCredentialKey(providerName) {
+    return (CREDENTIAL_KEY_MAP[providerName.toLowerCase()] ?? providerName.toLowerCase());
+}
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements
@@ -58,21 +82,7 @@ export class ProviderFactory {
             // Fallback to registry default if no env var
             model = model || registration.defaultModel;
         }
-        // Map registered provider names to NeurolinkCredentials keys.
-        // Most names match (openai, anthropic, vertex, bedrock, etc.)
-        // but every kebab-case provider whose canonical credentials key is
-        // camelCase MUST be mapped here — otherwise per-call credential
-        // overrides silently get dropped (the factory looks up
-        // credentials["lm-studio"] which is undefined while the user wrote
-        // credentials.lmStudio).
-        const credentialKeyMap = {
-            "google-ai": "googleAiStudio",
-            "openai-compatible": "openaiCompatible",
-            huggingface: "huggingFace",
-            "lm-studio": "lmStudio",
-            "nvidia-nim": "nvidiaNim",
-        };
-        const credKey = credentialKeyMap[normalizedName] ?? normalizedName;
+        const credKey = resolveCredentialKey(normalizedName);
         // Extract provider-scoped credential slice (e.g. credentials.openai for OpenAI)
         const scopedCredentials = credentials
             ? credentials[credKey]
@@ -81,30 +91,8 @@ export class ProviderFactory {
             if (typeof registration.constructor !== "function") {
                 throw new Error(`Invalid constructor for provider ${providerName}: not a function`);
             }
-            let result;
-            try {
-                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
-                // Handle both sync and async results
-                result =
-                    factoryResult instanceof Promise
-                        ? await factoryResult
-                        : factoryResult;
-            }
-            catch (factoryError) {
-                if (registration.constructor.prototype &&
-                    registration.constructor.prototype.constructor ===
-                        registration.constructor) {
-                    try {
-                        result = new registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
-                    }
-                    catch (constructorError) {
-                        throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`, { cause: constructorError });
-                    }
-                }
-                else {
-                    throw factoryError;
-                }
-            }
+            const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
+            const result = factoryResult instanceof Promise ? await factoryResult : factoryResult;
             return result;
         }
         catch (error) {

package/dist/lib/factories/providerRegistry.js

@@ -104,10 +104,10 @@ export class ProviderRegistry {
                 return new GoogleVertexProvider(modelName, providerName, sdk, region, vertexCreds);
             }, VertexModels.CLAUDE_4_6_SONNET, ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
-            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName, _providerName, _sdk, _region, credentials) => {
+            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName, _providerName, sdk, region, credentials) => {
                 const hfCreds = credentials;
                 const { HuggingFaceProvider } = await import("../providers/huggingFace/index.js");
-                return new HuggingFaceProvider(modelName, undefined, hfCreds);
+                return new HuggingFaceProvider(modelName, sdk, region, hfCreds);
             }, process.env.HUGGINGFACE_MODEL ||
                 HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["huggingface", "hf"]);
             // Register Mistral AI provider

package/dist/lib/models/anthropicModels.d.ts

@@ -242,13 +242,6 @@ export declare function getContextWindow(model: string): number;
  * @returns The max output tokens, or 0 if model not found
  */
 export declare function getMaxOutputTokens(model: string): number;
-/**
- * Check if a model supports vision/image input
- *
- * @param model - The model ID
- * @returns true if the model supports vision
- */
-export declare function supportsVision(model: string): boolean;
 /**
  * Check if a model supports extended thinking
  *

package/dist/lib/models/anthropicModels.js

@@ -531,15 +531,6 @@ export function getContextWindow(model) {
 export function getMaxOutputTokens(model) {
     return MODEL_METADATA[model]?.maxOutputTokens ?? 0;
 }
-/**
- * Check if a model supports vision/image input
- *
- * @param model - The model ID
- * @returns true if the model supports vision
- */
-export function supportsVision(model) {
-    return MODEL_METADATA[model]?.supportsVision ?? false;
-}
 /**
  * Check if a model supports extended thinking
  *

package/dist/lib/neurolink.d.ts

@@ -775,6 +775,21 @@ export declare class NeuroLink {
     private applyClassifierRouting;
     private prepareGenerateAugmentations;
     private buildGenerateTextOptions;
+    /**
+     * Provider-agnostic JSON recovery for schema requests. Structured-output
+     * enforcement makes valid JSON the overwhelming case; for every other
+     * provider path — including generate() overrides (Vertex, Anthropic,
+     * Bedrock, Google AI Studio) — object/array roots are recovered here via
+     * balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
+     * with the parsed value exposed as `structuredData`. If nothing JSON-shaped
+     * is recoverable (pure prose), the raw text is returned, `structuredData`
+     * stays undefined, and a WARN makes the case observable.
+     *
+     * Mutates `textResult` in place, and must run BEFORE the end-of-generation
+     * emits so event consumers see the same content/structuredData the caller
+     * receives.
+     */
+    private recoverStructuredData;
     private finalizeGenerateRequestResult;
     private emitGenerateErrorEvent;
     /**