@juspay/neurolink 9.51.4 → 9.53.0

package/dist/core/baseProvider.js

@@ -776,6 +776,24 @@ export class BaseProvider {
             },
             responseTime: 0, // BaseProvider doesn't track response time directly
             toolsUsed: result.toolsUsed || [],
+            // Map toolExecutions from EnhancedGenerateResult shape to TextGenerationResult shape
+            // Preserve original timing/status fields when present, fall back to safe defaults
+            toolExecutions: result.toolExecutions?.map((te) => {
+                const t = te;
+                return {
+                    // Spread original fields first so normalized fields take precedence
+                    ...te,
+                    toolName: te.name,
+                    executionTime: typeof t.executionTime === "number"
+                        ? t.executionTime
+                        : typeof t.duration === "number"
+                            ? t.duration
+                            : 0,
+                    success: typeof t.success === "boolean"
+                        ? t.success
+                        : t.status === undefined || t.status === "success",
+                };
+            }),
             enhancedWithTools: !!(result.toolsUsed && result.toolsUsed.length > 0),
             analytics: result.analytics,
             evaluation: result.evaluation,

package/dist/core/factory.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, SupportedModelName } from "../types/index.js";
+import type { AIProvider, SupportedModelName, NeurolinkCredentials } from "../types/index.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { UnknownRecord } from "../types/common.js";
 import type { ProviderPairResult } from "../types/typeAliases.js";
@@ -27,7 +27,7 @@ export declare class AIProviderFactory {
      * @param region - Optional region override for cloud providers
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord, region?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value

package/dist/core/factory.js

@@ -167,7 +167,7 @@ export class AIProviderFactory {
             return resolvedModelName;
         }
     }
-    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag) {
+    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials) {
         await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, ErrorFactory.toolTimeout("provider-registration", 30_000));
         const normalizedName = this.normalizeProviderName(providerName);
         const finalModelName = resolvedModelName === "default" || resolvedModelName === null
@@ -179,7 +179,7 @@ export class AIProviderFactory {
             resolvedModelName: resolvedModelName || "not resolved",
             finalModelName: finalModelName || "using provider default",
         });
-        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region), 30_000, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
+        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region, credentials), 30_000, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
         return { normalizedName, finalModelName, provider };
     }
     /**
@@ -191,7 +191,7 @@ export class AIProviderFactory {
      * @param region - Optional region override for cloud providers
      * @returns AIProvider instance
      */
-    static async createProvider(providerName, modelName, enableMCP = true, sdk, region) {
+    static async createProvider(providerName, modelName, enableMCP = true, sdk, region, credentials) {
         const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
         return factoryTracer.startActiveSpan("neurolink.factory.createProvider", {
@@ -225,7 +225,7 @@ export class AIProviderFactory {
                 // The dynamic model provider now provides reliable functionality without hanging
                 let resolvedModelName = this.resolveModelFromEnvironment(providerName, modelName, functionTag);
                 resolvedModelName = await this.resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag);
-                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag);
+                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials);
                 // Summary logging in format expected by debugging tools
                 logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
                 logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);

package/dist/evaluation/errors/EvaluationError.d.ts

@@ -69,7 +69,7 @@ export declare const evaluationErrors: {
         /** Rate limit hit during evaluation */
         readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
     };
-    create: (code: "PROVIDER_ERROR" | "CONFIGURATION_ERROR" | "EVALUATION_FAILED" | "PARSE_ERROR" | "STRATEGY_NOT_FOUND" | "CUSTOM_EVALUATOR_ERROR" | "BATCH_EVALUATION_ERROR" | "AGGREGATION_ERROR" | "REGISTRY_ERROR" | "MAX_RETRIES_EXCEEDED" | "TIMEOUT_ERROR" | "RATE_LIMIT_ERROR", message: string, options?: {
+    create: (code: "EVALUATION_FAILED" | "PARSE_ERROR" | "STRATEGY_NOT_FOUND" | "PROVIDER_ERROR" | "CONFIGURATION_ERROR" | "CUSTOM_EVALUATOR_ERROR" | "BATCH_EVALUATION_ERROR" | "AGGREGATION_ERROR" | "REGISTRY_ERROR" | "MAX_RETRIES_EXCEEDED" | "TIMEOUT_ERROR" | "RATE_LIMIT_ERROR", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/factories/providerFactory.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { UnknownRecord } from "../types/common.js";
-import type { AIProvider } from "../types/index.js";
+import type { AIProvider, NeurolinkCredentials } from "../types/index.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
@@ -33,7 +33,7 @@ export declare class ProviderFactory {
      * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
      * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
-    static createProvider(providerName?: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
+    static createProvider(providerName?: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */
@@ -67,10 +67,10 @@ export declare class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord, credentials?: NeurolinkCredentials): Promise<AIProvider>;
 }
 /**
  * Helper function to create providers with backward compatibility
  */
-export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string): Promise<AIProvider>;
+export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
 export {};

package/dist/factories/providerFactory.js

@@ -30,7 +30,7 @@ export class ProviderFactory {
      * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
      * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
-    static async createProvider(providerName, modelName, sdk, region) {
+    static async createProvider(providerName, modelName, sdk, region, credentials) {
         // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
         // Use environment variable or default if not specified
         const resolvedProviderName = providerName ||
@@ -56,13 +56,26 @@ 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 some differ (google-ai → googleAiStudio, openai-compatible → openaiCompatible).
+        const credentialKeyMap = {
+            "google-ai": "googleAiStudio",
+            "openai-compatible": "openaiCompatible",
+            huggingface: "huggingFace",
+        };
+        const credKey = credentialKeyMap[normalizedName] ?? normalizedName;
+        // Extract provider-scoped credential slice (e.g. credentials.openai for OpenAI)
+        const scopedCredentials = credentials
+            ? credentials[credKey]
+            : undefined;
         try {
             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);
+                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
                 // Handle both sync and async results
                 result =
                     factoryResult instanceof Promise
@@ -74,7 +87,7 @@ export class ProviderFactory {
                     registration.constructor.prototype.constructor ===
                         registration.constructor) {
                     try {
-                        result = new registration.constructor(model, resolvedProviderName, sdk, region);
+                        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 });
@@ -154,13 +167,13 @@ export class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static async createBestProvider(providerName, modelName, enableMCP, sdk) {
-        return await ProviderFactory.createProvider(providerName, modelName, sdk);
+    static async createBestProvider(providerName, modelName, enableMCP, sdk, credentials) {
+        return await ProviderFactory.createProvider(providerName, modelName, sdk, undefined, credentials);
     }
 }
 /**
  * Helper function to create providers with backward compatibility
  */
-export async function createAIProvider(providerName, modelName) {
-    return await ProviderFactory.createProvider(providerName, modelName);
+export async function createAIProvider(providerName, modelName, credentials) {
+    return await ProviderFactory.createProvider(providerName, modelName, undefined, undefined, credentials);
 }

package/dist/factories/providerRegistry.d.ts

@@ -13,6 +13,11 @@ export declare class ProviderRegistry {
     static registerAllProviders(): Promise<void>;
     /**
      * Internal registration implementation
+     *
+     * This method is a flat list of 13 provider registrations. Each registration
+     * is self-contained and extracting helpers would add indirection without
+     * reducing complexity — the function is long because there are many providers,
+     * not because any single registration is complex.
      */
     private static _doRegister;
     /**

package/dist/factories/providerRegistry.js

@@ -32,82 +32,101 @@ export class ProviderRegistry {
     }
     /**
      * Internal registration implementation
+     *
+     * This method is a flat list of 13 provider registrations. Each registration
+     * is self-contained and extracting helpers would add indirection without
+     * reducing complexity — the function is long because there are many providers,
+     * not because any single registration is complex.
      */
+    // eslint-disable-next-line max-lines-per-function
     static async _doRegister() {
         try {
             // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
             // Register Google AI Studio Provider (our validated baseline)
-            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk, _region, credentials) => {
+                const googleAiCreds = credentials;
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
-                return new GoogleAIStudioProvider(modelName, sdk);
+                return new GoogleAIStudioProvider(modelName, sdk, googleAiCreds);
             }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"]);
             // Register OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openaiCreds = credentials;
                 const { OpenAIProvider } = await import("../providers/openAI.js");
-                return new OpenAIProvider(modelName, sdk);
+                return new OpenAIProvider(modelName, sdk, undefined, openaiCreds);
             }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
             // Register Anthropic provider
-            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk, _region, credentials) => {
+                const anthropicCreds = credentials;
                 const { AnthropicProvider } = await import("../providers/anthropic.js");
-                return new AnthropicProvider(modelName, sdk);
+                return new AnthropicProvider(modelName, sdk, undefined, anthropicCreds);
             }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region, credentials) => {
+                const bedrockCreds = credentials;
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName, sdk, region);
+                return new AmazonBedrockProvider(modelName, sdk, region, bedrockCreds);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk, _region, credentials) => {
+                const azureCreds = credentials;
                 const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
-                return new AzureOpenAIProvider(modelName, sdk);
+                return new AzureOpenAIProvider(modelName, sdk, undefined, azureCreds);
             }, process.env.AZURE_MODEL ||
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o-mini", ["azure", "azureOpenai"]);
             // Register Google Vertex AI provider
-            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region, credentials) => {
+                const vertexCreds = credentials;
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName, providerName, sdk, region);
+                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) => {
+            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName, _providerName, _sdk, _region, credentials) => {
+                const hfCreds = credentials;
                 const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
-                return new HuggingFaceProvider(modelName);
+                return new HuggingFaceProvider(modelName, undefined, hfCreds);
             }, process.env.HUGGINGFACE_MODEL ||
                 HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["huggingface", "hf"]);
             // Register Mistral AI provider
-            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk, _region, credentials) => {
+                const mistralCreds = credentials;
                 const { MistralProvider } = await import("../providers/mistral.js");
-                return new MistralProvider(modelName, sdk);
+                return new MistralProvider(modelName, sdk, undefined, mistralCreds);
             }, MistralModels.MISTRAL_LARGE_LATEST, ["mistral"]);
             // Register Ollama provider
-            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName, _providerName, _sdk, _region, credentials) => {
+                const ollamaCreds = credentials;
                 const { OllamaProvider } = await import("../providers/ollama.js");
-                return new OllamaProvider(modelName);
+                return new OllamaProvider(modelName, ollamaCreds);
             }, process.env.OLLAMA_MODEL || OllamaModels.LLAMA3_2_LATEST, ["ollama", "local"]);
             // Register LiteLLM provider
-            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk, _region, credentials) => {
+                const litellmCreds = credentials;
                 const { LiteLLMProvider } = await import("../providers/litellm.js");
-                return new LiteLLMProvider(modelName, sdk);
+                return new LiteLLMProvider(modelName, sdk, undefined, litellmCreds);
             }, process.env.LITELLM_MODEL || LiteLLMModels.OPENAI_GPT_4O_MINI, ["litellm"]);
             // Register OpenAI Compatible provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openaiCompatCreds = credentials;
                 const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
-                return new OpenAICompatibleProvider(modelName, sdk);
+                return new OpenAICompatibleProvider(modelName, sdk, undefined, openaiCompatCreds);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "vllm", "compatible"]);
             // Register OpenRouter provider (300+ models from 60+ providers)
-            ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openrouterCreds = credentials;
                 const { OpenRouterProvider } = await import("../providers/openRouter.js");
-                return new OpenRouterProvider(modelName, sdk);
+                return new OpenRouterProvider(modelName, sdk, undefined, openrouterCreds);
             }, process.env.OPENROUTER_MODEL || "anthropic/claude-3-5-sonnet", ["openrouter", "or"]);
             // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region, credentials) => {
+                const sagemakerCreds = credentials;
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
-                return new AmazonSageMakerProvider(modelName, undefined, region);
+                return new AmazonSageMakerProvider(modelName, undefined, region, undefined, sagemakerCreds);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
             logger.debug("All providers registered successfully");
             this.registered = true;

package/dist/lib/agent/directTools.d.ts

@@ -101,7 +101,7 @@ export declare const directAgentTools: {
     writeFile: import("ai").Tool<{
         path: string;
         content: string;
-        mode: "create" | "append" | "overwrite";
+        mode: "append" | "create" | "overwrite";
     }, {
         success: boolean;
         error: string;
@@ -112,7 +112,7 @@ export declare const directAgentTools: {
     } | {
         success: boolean;
         path: string;
-        mode: "create" | "append" | "overwrite";
+        mode: "append" | "create" | "overwrite";
         size: number;
         written: number;
         error?: undefined;

package/dist/lib/auth/errors.d.ts

@@ -55,7 +55,7 @@ export declare const AuthError: {
         readonly JWKS_FETCH_FAILED: "AUTH-070";
         readonly JWKS_KEY_NOT_FOUND: "AUTH-071";
     };
-    create: (code: "SESSION_NOT_FOUND" | "INVALID_TOKEN" | "EXPIRED_TOKEN" | "MISSING_TOKEN" | "TOKEN_DECODE_FAILED" | "INVALID_SIGNATURE" | "SESSION_EXPIRED" | "SESSION_REVOKED" | "INSUFFICIENT_PERMISSIONS" | "INSUFFICIENT_ROLES" | "ACCESS_DENIED" | "USER_NOT_FOUND" | "USER_DISABLED" | "EMAIL_NOT_VERIFIED" | "MFA_REQUIRED" | "PROVIDER_ERROR" | "PROVIDER_NOT_FOUND" | "PROVIDER_INIT_FAILED" | "CONFIGURATION_ERROR" | "CREATION_FAILED" | "REGISTRATION_FAILED" | "DUPLICATE_REGISTRATION" | "MIDDLEWARE_ERROR" | "RATE_LIMITED" | "JWKS_FETCH_FAILED" | "JWKS_KEY_NOT_FOUND", message: string, options?: {
+    create: (code: "SESSION_NOT_FOUND" | "CONFIGURATION_ERROR" | "RATE_LIMITED" | "PROVIDER_ERROR" | "MIDDLEWARE_ERROR" | "INVALID_TOKEN" | "EXPIRED_TOKEN" | "MISSING_TOKEN" | "TOKEN_DECODE_FAILED" | "INVALID_SIGNATURE" | "SESSION_EXPIRED" | "SESSION_REVOKED" | "INSUFFICIENT_PERMISSIONS" | "INSUFFICIENT_ROLES" | "ACCESS_DENIED" | "USER_NOT_FOUND" | "USER_DISABLED" | "EMAIL_NOT_VERIFIED" | "MFA_REQUIRED" | "PROVIDER_NOT_FOUND" | "PROVIDER_INIT_FAILED" | "CREATION_FAILED" | "REGISTRATION_FAILED" | "DUPLICATE_REGISTRATION" | "JWKS_FETCH_FAILED" | "JWKS_KEY_NOT_FOUND", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/lib/auth/middleware/AuthMiddleware.d.ts

@@ -31,7 +31,7 @@ export declare const AuthMiddlewareError: {
         readonly PROVIDER_ERROR: "AUTH_MIDDLEWARE-005";
         readonly CONFIGURATION_ERROR: "AUTH_MIDDLEWARE-006";
     };
-    create: (code: "INVALID_TOKEN" | "MISSING_TOKEN" | "PROVIDER_ERROR" | "CONFIGURATION_ERROR" | "UNAUTHORIZED" | "FORBIDDEN", message: string, options?: {
+    create: (code: "CONFIGURATION_ERROR" | "UNAUTHORIZED" | "FORBIDDEN" | "PROVIDER_ERROR" | "INVALID_TOKEN" | "MISSING_TOKEN", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/lib/auth/providers/BaseAuthProvider.d.ts

@@ -44,7 +44,7 @@ export declare const AuthProviderError: {
         readonly JWKS_FETCH_FAILED: "AUTH-070";
         readonly JWKS_KEY_NOT_FOUND: "AUTH-071";
     };
-    create: (code: "SESSION_NOT_FOUND" | "INVALID_TOKEN" | "EXPIRED_TOKEN" | "MISSING_TOKEN" | "TOKEN_DECODE_FAILED" | "INVALID_SIGNATURE" | "SESSION_EXPIRED" | "SESSION_REVOKED" | "INSUFFICIENT_PERMISSIONS" | "INSUFFICIENT_ROLES" | "ACCESS_DENIED" | "USER_NOT_FOUND" | "USER_DISABLED" | "EMAIL_NOT_VERIFIED" | "MFA_REQUIRED" | "PROVIDER_ERROR" | "PROVIDER_NOT_FOUND" | "PROVIDER_INIT_FAILED" | "CONFIGURATION_ERROR" | "CREATION_FAILED" | "REGISTRATION_FAILED" | "DUPLICATE_REGISTRATION" | "MIDDLEWARE_ERROR" | "RATE_LIMITED" | "JWKS_FETCH_FAILED" | "JWKS_KEY_NOT_FOUND", message: string, options?: {
+    create: (code: "SESSION_NOT_FOUND" | "CONFIGURATION_ERROR" | "RATE_LIMITED" | "PROVIDER_ERROR" | "MIDDLEWARE_ERROR" | "INVALID_TOKEN" | "EXPIRED_TOKEN" | "MISSING_TOKEN" | "TOKEN_DECODE_FAILED" | "INVALID_SIGNATURE" | "SESSION_EXPIRED" | "SESSION_REVOKED" | "INSUFFICIENT_PERMISSIONS" | "INSUFFICIENT_ROLES" | "ACCESS_DENIED" | "USER_NOT_FOUND" | "USER_DISABLED" | "EMAIL_NOT_VERIFIED" | "MFA_REQUIRED" | "PROVIDER_NOT_FOUND" | "PROVIDER_INIT_FAILED" | "CREATION_FAILED" | "REGISTRATION_FAILED" | "DUPLICATE_REGISTRATION" | "JWKS_FETCH_FAILED" | "JWKS_KEY_NOT_FOUND", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/lib/autoresearch/config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Research configuration validation and resolution.
+ */
+import type { ResearchConfig } from "../types/autoresearchTypes.js";
+export declare function resolveConfig(partial: Partial<ResearchConfig> & {
+    repoPath: string;
+    mutablePaths: string[];
+    runCommand: string;
+    metric: ResearchConfig["metric"];
+}): ResearchConfig;
+export declare function validateConfig(config: ResearchConfig): void;

package/dist/lib/autoresearch/config.js

@@ -0,0 +1,109 @@
+/**
+ * Research configuration validation and resolution.
+ */
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { AutoresearchError } from "./errors.js";
+import { AUTORESEARCH_DEFAULTS } from "../types/autoresearchTypes.js";
+export function resolveConfig(partial) {
+    const config = {
+        repoPath: path.resolve(partial.repoPath),
+        programPath: partial.programPath ?? AUTORESEARCH_DEFAULTS.programPath,
+        mutablePaths: partial.mutablePaths,
+        immutablePaths: partial.immutablePaths ?? [],
+        resultsPath: partial.resultsPath ?? AUTORESEARCH_DEFAULTS.resultsPath,
+        statePath: partial.statePath ?? AUTORESEARCH_DEFAULTS.statePath,
+        runCommand: partial.runCommand,
+        logPath: partial.logPath ?? AUTORESEARCH_DEFAULTS.logPath,
+        metric: partial.metric,
+        memoryMetric: partial.memoryMetric,
+        timeoutMs: partial.timeoutMs ?? AUTORESEARCH_DEFAULTS.timeoutMs,
+        branchPrefix: partial.branchPrefix ?? AUTORESEARCH_DEFAULTS.branchPrefix,
+        provider: partial.provider,
+        model: partial.model,
+        maxExperiments: partial.maxExperiments,
+        thinkingLevel: partial.thinkingLevel ?? AUTORESEARCH_DEFAULTS.thinkingLevel,
+    };
+    return config;
+}
+export function validateConfig(config) {
+    // Verify repoPath exists and is a directory
+    if (!existsSync(config.repoPath) ||
+        !statSync(config.repoPath).isDirectory()) {
+        throw AutoresearchError.create("CONFIG_INVALID", `repoPath does not exist or is not a directory: ${config.repoPath}`);
+    }
+    // Verify it's a git repo
+    if (!existsSync(path.join(config.repoPath, ".git"))) {
+        throw AutoresearchError.create("REPO_NOT_FOUND", `repoPath is not a git repository: ${config.repoPath}`);
+    }
+    // Verify mutablePaths is non-empty
+    if (config.mutablePaths.length === 0) {
+        throw AutoresearchError.create("CONFIG_INVALID", "mutablePaths must contain at least one path");
+    }
+    // Verify mutable and immutable don't overlap (normalize paths first)
+    const normMutable = config.mutablePaths.map((p) => path.normalize(p).replace(/\/+$/, ""));
+    const normImmutable = config.immutablePaths.map((p) => path.normalize(p).replace(/\/+$/, ""));
+    const overlap = normMutable.filter((p) => normImmutable.includes(p));
+    if (overlap.length > 0) {
+        throw AutoresearchError.create("CONFIG_INVALID", `mutablePaths and immutablePaths overlap: ${overlap.join(", ")}`);
+    }
+    // Verify metric pattern — length limit and basic ReDoS safety
+    const MAX_PATTERN_LENGTH = 200;
+    if (config.metric.pattern.length > MAX_PATTERN_LENGTH) {
+        throw AutoresearchError.create("CONFIG_INVALID", `metric.pattern exceeds ${MAX_PATTERN_LENGTH} characters: ${config.metric.pattern.slice(0, 50)}...`);
+    }
+    // Reject patterns with obvious catastrophic backtracking (nested quantifiers)
+    if (/(\+|\*|\{)\s*(\+|\*|\{)/.test(config.metric.pattern) ||
+        /\(\?[^)]*\)\+\+/.test(config.metric.pattern)) {
+        throw AutoresearchError.create("CONFIG_INVALID", `metric.pattern contains nested quantifiers (potential ReDoS): ${config.metric.pattern}`);
+    }
+    // Verify metric pattern is valid regex with exactly one capture group
+    try {
+        const _regex = new RegExp(config.metric.pattern);
+        const match = new RegExp(config.metric.pattern + "|").exec("");
+        const groupCount = (match?.length ?? 1) - 1;
+        if (groupCount !== 1) {
+            throw AutoresearchError.create("CONFIG_INVALID", `metric.pattern must have exactly one capture group, found ${groupCount}: ${config.metric.pattern}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            typeof error.code === "string") {
+            throw error; // Rethrow structured AutoresearchError
+        }
+        throw AutoresearchError.create("CONFIG_INVALID", `metric.pattern is not a valid regex: ${config.metric.pattern}`);
+    }
+    // Validate memoryMetric.pattern with the same checks if present
+    if (config.memoryMetric) {
+        if (config.memoryMetric.pattern.length > MAX_PATTERN_LENGTH) {
+            throw AutoresearchError.create("CONFIG_INVALID", `memoryMetric.pattern exceeds ${MAX_PATTERN_LENGTH} characters`);
+        }
+        if (/(\+|\*|\{)\s*(\+|\*|\{)/.test(config.memoryMetric.pattern) ||
+            /\(\?[^)]*\)\+\+/.test(config.memoryMetric.pattern)) {
+            throw AutoresearchError.create("CONFIG_INVALID", `memoryMetric.pattern contains nested quantifiers (potential ReDoS)`);
+        }
+        try {
+            const _memRegex = new RegExp(config.memoryMetric.pattern);
+            const memMatch = new RegExp(config.memoryMetric.pattern + "|").exec("");
+            const memGroupCount = (memMatch?.length ?? 1) - 1;
+            if (memGroupCount !== 1) {
+                throw AutoresearchError.create("CONFIG_INVALID", `memoryMetric.pattern must have exactly one capture group, found ${memGroupCount}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                typeof error.code === "string") {
+                throw error; // Rethrow structured AutoresearchError
+            }
+            throw AutoresearchError.create("CONFIG_INVALID", `memoryMetric.pattern is not a valid regex: ${config.memoryMetric.pattern}`);
+        }
+    }
+    logger.info("[Autoresearch] Config validated", {
+        repoPath: config.repoPath,
+        mutablePaths: config.mutablePaths,
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/lib/autoresearch/errors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Error definitions for the NeuroLink AutoResearch system.
+ */
+export declare const AutoresearchErrorCodes: {
+    readonly CONFIG_INVALID: "AUTORESEARCH-001";
+    readonly STATE_CORRUPT: "AUTORESEARCH-002";
+    readonly STATE_NOT_FOUND: "AUTORESEARCH-003";
+    readonly REPO_NOT_FOUND: "AUTORESEARCH-004";
+    readonly BRANCH_ERROR: "AUTORESEARCH-005";
+    readonly PATH_VIOLATION: "AUTORESEARCH-006";
+    readonly COMMIT_REJECTED: "AUTORESEARCH-007";
+    readonly EXPERIMENT_TIMEOUT: "AUTORESEARCH-008";
+    readonly EXPERIMENT_FAILED: "AUTORESEARCH-009";
+    readonly PARSE_FAILED: "AUTORESEARCH-010";
+    readonly RESULTS_WRITE_FAILED: "AUTORESEARCH-011";
+    readonly REVERT_FAILED: "AUTORESEARCH-012";
+    readonly WORKER_NOT_INITIALIZED: "AUTORESEARCH-013";
+};
+export declare const AutoresearchError: {
+    codes: {
+        readonly CONFIG_INVALID: "AUTORESEARCH-001";
+        readonly STATE_CORRUPT: "AUTORESEARCH-002";
+        readonly STATE_NOT_FOUND: "AUTORESEARCH-003";
+        readonly REPO_NOT_FOUND: "AUTORESEARCH-004";
+        readonly BRANCH_ERROR: "AUTORESEARCH-005";
+        readonly PATH_VIOLATION: "AUTORESEARCH-006";
+        readonly COMMIT_REJECTED: "AUTORESEARCH-007";
+        readonly EXPERIMENT_TIMEOUT: "AUTORESEARCH-008";
+        readonly EXPERIMENT_FAILED: "AUTORESEARCH-009";
+        readonly PARSE_FAILED: "AUTORESEARCH-010";
+        readonly RESULTS_WRITE_FAILED: "AUTORESEARCH-011";
+        readonly REVERT_FAILED: "AUTORESEARCH-012";
+        readonly WORKER_NOT_INITIALIZED: "AUTORESEARCH-013";
+    };
+    create: (code: "CONFIG_INVALID" | "STATE_CORRUPT" | "STATE_NOT_FOUND" | "REPO_NOT_FOUND" | "BRANCH_ERROR" | "PATH_VIOLATION" | "COMMIT_REJECTED" | "EXPERIMENT_TIMEOUT" | "EXPERIMENT_FAILED" | "PARSE_FAILED" | "RESULTS_WRITE_FAILED" | "REVERT_FAILED" | "WORKER_NOT_INITIALIZED", message: string, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    } | undefined) => import("../core/infrastructure/baseError.js").NeuroLinkFeatureError;
+};

package/dist/lib/autoresearch/errors.js

@@ -0,0 +1,21 @@
+/**
+ * Error definitions for the NeuroLink AutoResearch system.
+ */
+import { createErrorFactory } from "../core/infrastructure/baseError.js";
+export const AutoresearchErrorCodes = {
+    CONFIG_INVALID: "AUTORESEARCH-001",
+    STATE_CORRUPT: "AUTORESEARCH-002",
+    STATE_NOT_FOUND: "AUTORESEARCH-003",
+    REPO_NOT_FOUND: "AUTORESEARCH-004",
+    BRANCH_ERROR: "AUTORESEARCH-005",
+    PATH_VIOLATION: "AUTORESEARCH-006",
+    COMMIT_REJECTED: "AUTORESEARCH-007",
+    EXPERIMENT_TIMEOUT: "AUTORESEARCH-008",
+    EXPERIMENT_FAILED: "AUTORESEARCH-009",
+    PARSE_FAILED: "AUTORESEARCH-010",
+    RESULTS_WRITE_FAILED: "AUTORESEARCH-011",
+    REVERT_FAILED: "AUTORESEARCH-012",
+    WORKER_NOT_INITIALIZED: "AUTORESEARCH-013",
+};
+export const AutoresearchError = createErrorFactory("Autoresearch", AutoresearchErrorCodes);
+//# sourceMappingURL=errors.js.map

package/dist/lib/autoresearch/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * NeuroLink AutoResearch — Autonomous Experiment Engine
+ *
+ * An autonomous experiment loop that proposes code changes, executes
+ * experiments, evaluates results against a deterministic metric, and
+ * keeps or discards each change — running unattended for hours.
+ *
+ * @example
+ * ```typescript
+ * import { resolveConfig, validateConfig, ResearchStateStore, RepoPolicy, ExperimentRunner, ResultRecorder } from "@juspay/neurolink/autoresearch";
+ * ```
+ */
+export { resolveConfig, validateConfig } from "./config.js";
+export { ResearchStateStore } from "./stateStore.js";
+export { RepoPolicy } from "./repoPolicy.js";
+export { ExperimentRunner } from "./runner.js";
+export { ResultRecorder } from "./resultRecorder.js";
+export { parseExperimentSummary } from "./summaryParser.js";
+export { getPhaseToolPolicy, getAllResearchToolNames } from "./phasePolicy.js";
+export { PromptCompiler } from "./promptCompiler.js";
+export { createResearchTools } from "./tools.js";
+export { ResearchWorker } from "./worker.js";
+export { AutoresearchError, AutoresearchErrorCodes } from "./errors.js";

package/dist/lib/autoresearch/index.js

@@ -0,0 +1,35 @@
+/**
+ * NeuroLink AutoResearch — Autonomous Experiment Engine
+ *
+ * An autonomous experiment loop that proposes code changes, executes
+ * experiments, evaluates results against a deterministic metric, and
+ * keeps or discards each change — running unattended for hours.
+ *
+ * @example
+ * ```typescript
+ * import { resolveConfig, validateConfig, ResearchStateStore, RepoPolicy, ExperimentRunner, ResultRecorder } from "@juspay/neurolink/autoresearch";
+ * ```
+ */
+// Configuration
+export { resolveConfig, validateConfig } from "./config.js";
+// State management
+export { ResearchStateStore } from "./stateStore.js";
+// Policy enforcement
+export { RepoPolicy } from "./repoPolicy.js";
+// Experiment execution
+export { ExperimentRunner } from "./runner.js";
+// Result tracking
+export { ResultRecorder } from "./resultRecorder.js";
+// Log parsing
+export { parseExperimentSummary } from "./summaryParser.js";
+// Phase policy
+export { getPhaseToolPolicy, getAllResearchToolNames } from "./phasePolicy.js";
+// Prompt compilation
+export { PromptCompiler } from "./promptCompiler.js";
+// Research tools
+export { createResearchTools } from "./tools.js";
+// Worker orchestrator
+export { ResearchWorker } from "./worker.js";
+// Errors
+export { AutoresearchError, AutoresearchErrorCodes } from "./errors.js";
+//# sourceMappingURL=index.js.map