@juspay/neurolink 9.51.4 → 9.53.0

package/dist/lib/autoresearch/worker.js

@@ -0,0 +1,418 @@
+/**
+ * Research worker — orchestrates the full experiment loop.
+ *
+ * Wires tools, state, policy, and NeuroLink generate() into a
+ * single experiment cycle. Can run standalone or via TaskManager.
+ *
+ * Emits autoresearch:* lifecycle events through an injected emitter
+ * and wraps key operations in OpenTelemetry spans for observability.
+ */
+import { execFileSync } from "node:child_process";
+import { ATTR } from "../telemetry/attributes.js";
+import { tracers } from "../telemetry/tracers.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { withTimeout } from "../utils/errorHandling.js";
+import { logger } from "../utils/logger.js";
+import { resolveConfig, validateConfig } from "./config.js";
+import { AutoresearchError } from "./errors.js";
+import { getPhaseToolPolicy } from "./phasePolicy.js";
+import { PromptCompiler } from "./promptCompiler.js";
+import { RepoPolicy } from "./repoPolicy.js";
+import { ResultRecorder } from "./resultRecorder.js";
+import { ExperimentRunner } from "./runner.js";
+import { ResearchStateStore } from "./stateStore.js";
+import { createResearchTools } from "./tools.js";
+function isBetter(candidate, best, direction) {
+    return direction === "lower" ? candidate < best : candidate > best;
+}
+function decideOutcome(metric, crashed, timedOut, bestMetric, direction) {
+    if (timedOut) {
+        return "timeout";
+    }
+    if (crashed || metric === null) {
+        return "crash";
+    }
+    if (bestMetric === null) {
+        return "keep";
+    } // First run is baseline
+    return isBetter(metric, bestMetric, direction) ? "keep" : "discard";
+}
+export class ResearchWorker {
+    config;
+    stateStore;
+    repoPolicy;
+    runner;
+    recorder;
+    promptCompiler;
+    initialized = false;
+    /** Event emitter injected by NeuroLink/TaskManager for lifecycle events. */
+    emitter;
+    constructor(configInput) {
+        this.config = resolveConfig(configInput);
+        this.stateStore = new ResearchStateStore(this.config.repoPath, this.config.statePath);
+        this.repoPolicy = new RepoPolicy(this.config);
+        this.runner = new ExperimentRunner(this.config);
+        this.recorder = new ResultRecorder(this.config);
+        this.promptCompiler = new PromptCompiler(this.config);
+    }
+    // ── Emitter integration ──────────────────────────────────
+    /** Set the event emitter (called by NeuroLink/TaskManager during integration). */
+    setEmitter(emitter) {
+        this.emitter = emitter;
+    }
+    /** Emit a lifecycle event. Safe to call when no emitter is set. */
+    emit(event, ...args) {
+        this.emitter?.emit(event, ...args);
+    }
+    // ── Lifecycle ────────────────────────────────────────────
+    /** Initialize: validate config, ensure branch, create state */
+    async initialize(tag) {
+        return withSpan({
+            name: "autoresearch.initialize",
+            tracer: tracers.autoresearch,
+            attributes: {
+                [ATTR.AR_TAG]: tag,
+                [ATTR.AR_BRANCH]: `${this.config.branchPrefix}${tag}`,
+            },
+        }, async (span) => {
+            validateConfig(this.config);
+            const branch = `${this.config.branchPrefix}${tag}`;
+            // Create branch if it doesn't exist
+            try {
+                const currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+                    cwd: this.config.repoPath,
+                    encoding: "utf-8",
+                }).trim();
+                if (currentBranch !== branch) {
+                    try {
+                        execFileSync("git", ["checkout", "-b", branch], {
+                            cwd: this.config.repoPath,
+                            stdio: "ignore",
+                        });
+                    }
+                    catch {
+                        // Branch may already exist
+                        execFileSync("git", ["checkout", branch], {
+                            cwd: this.config.repoPath,
+                            stdio: "ignore",
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.emitError(tag, "BRANCH_ERROR", `Failed to setup branch ${branch}`);
+                throw AutoresearchError.create("BRANCH_ERROR", `Failed to setup branch ${branch}`, {
+                    cause: error instanceof Error ? error : undefined,
+                });
+            }
+            // Initialize state
+            const state = await this.stateStore.initialize(tag, branch);
+            // Ensure results file exists
+            await this.recorder.ensureResultsFile();
+            this.initialized = true;
+            span.setAttribute(ATTR.AR_PHASE, state.currentPhase);
+            logger.info("[Autoresearch] Worker initialized", { tag, branch });
+            this.emit("autoresearch:initialized", {
+                tag,
+                branch,
+                config: {
+                    repoPath: this.config.repoPath,
+                    runCommand: this.config.runCommand,
+                    metric: this.config.metric,
+                    timeoutMs: this.config.timeoutMs,
+                },
+            });
+            return state;
+        });
+    }
+    /** Load existing state (for resuming) */
+    async resume() {
+        return withSpan({
+            name: "autoresearch.resume",
+            tracer: tracers.autoresearch,
+        }, async (span) => {
+            const state = await this.stateStore.load();
+            if (!state) {
+                throw AutoresearchError.create("STATE_NOT_FOUND", "No state file found. Run initialize() first.");
+            }
+            validateConfig(this.config);
+            // Ensure we're on the correct branch (may have changed after restart)
+            try {
+                const currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: this.config.repoPath, encoding: "utf-8" }).trim();
+                if (currentBranch !== state.branch) {
+                    execFileSync("git", ["checkout", state.branch], {
+                        cwd: this.config.repoPath,
+                        stdio: "ignore",
+                    });
+                }
+            }
+            catch (branchErr) {
+                logger.error("[Autoresearch] Failed to restore branch", {
+                    expected: state.branch,
+                    error: branchErr instanceof Error
+                        ? branchErr.message
+                        : String(branchErr),
+                });
+                throw AutoresearchError.create("BRANCH_ERROR", `Failed to checkout branch ${state.branch} during resume`, { cause: branchErr instanceof Error ? branchErr : undefined });
+            }
+            this.initialized = true;
+            span.setAttribute(ATTR.AR_TAG, state.tag);
+            span.setAttribute(ATTR.AR_BRANCH, state.branch);
+            span.setAttribute(ATTR.AR_RUN_COUNT, state.runCount);
+            span.setAttribute(ATTR.AR_PHASE, state.currentPhase);
+            this.emit("autoresearch:resumed", {
+                tag: state.tag,
+                branch: state.branch,
+                runCount: state.runCount,
+                currentPhase: state.currentPhase,
+            });
+            return state;
+        });
+    }
+    /** Run one full experiment cycle without AI — just the deterministic parts */
+    async runExperimentCycle(description) {
+        if (!this.initialized) {
+            throw AutoresearchError.create("WORKER_NOT_INITIALIZED", "Call initialize() or resume() first");
+        }
+        const state = await this.stateStore.load();
+        if (!state) {
+            throw AutoresearchError.create("STATE_NOT_FOUND", "State file missing");
+        }
+        return withSpan({
+            name: "autoresearch.experiment_cycle",
+            tracer: tracers.autoresearch,
+            attributes: {
+                [ATTR.AR_TAG]: state.tag,
+                [ATTR.AR_RUN_COUNT]: state.runCount,
+                [ATTR.AR_DESCRIPTION]: description,
+            },
+        }, async (span) => {
+            const cycleStart = Date.now();
+            this.emit("autoresearch:experiment-started", {
+                tag: state.tag,
+                runCount: state.runCount,
+                description,
+            });
+            await this.advancePhase("run");
+            // Run the experiment
+            logger.info("[Autoresearch] Running experiment", {
+                runCount: state.runCount,
+                description,
+            });
+            const summary = await withSpan({
+                name: "autoresearch.experiment_run",
+                tracer: tracers.autoresearch,
+                attributes: { [ATTR.AR_TAG]: state.tag },
+            }, async () => {
+                return withTimeout(this.runner.run(), this.config.timeoutMs + 30_000, new Error("Experiment runner exceeded safety timeout"));
+            });
+            await this.advancePhase("evaluate");
+            // Deterministic decision
+            const status = decideOutcome(summary.metric, summary.crashed, summary.timedOut, state.bestMetric, this.config.metric.direction);
+            // Get commit hash
+            const commit = this.repoPolicy.getHeadCommit() || "unknown";
+            // Build record
+            const record = {
+                commit,
+                metric: summary.metric,
+                memoryGb: summary.memoryValue,
+                status,
+                description,
+                timestamp: new Date().toISOString(),
+            };
+            // Record result
+            await this.recorder.appendTsv(record);
+            await this.recorder.appendJsonl(record);
+            await this.advancePhase("accept_or_revert");
+            // Update state based on outcome
+            if (status === "keep") {
+                await this.stateStore.update({
+                    acceptedCommit: commit,
+                    bestMetric: summary.metric,
+                    baselineMetric: state.baselineMetric ?? summary.metric,
+                    keepCount: state.keepCount + 1,
+                    runCount: state.runCount + 1,
+                    lastStatus: status,
+                    candidateCommit: null,
+                });
+                // Emit metric-improved if this beats a previous best
+                if (summary.metric !== null &&
+                    state.bestMetric !== null &&
+                    isBetter(summary.metric, state.bestMetric, this.config.metric.direction)) {
+                    this.emit("autoresearch:metric-improved", {
+                        tag: state.tag,
+                        previousBest: state.bestMetric,
+                        newBest: summary.metric,
+                        commit,
+                        direction: this.config.metric.direction,
+                        runCount: state.runCount + 1,
+                    });
+                }
+            }
+            else {
+                // Revert on discard/crash/timeout
+                if (state.acceptedCommit) {
+                    this.emit("autoresearch:revert", {
+                        tag: state.tag,
+                        targetCommit: state.acceptedCommit,
+                        reason: status,
+                        runCount: state.runCount,
+                    });
+                    try {
+                        execFileSync("git", ["reset", "--hard", state.acceptedCommit], {
+                            cwd: this.config.repoPath,
+                            stdio: "ignore",
+                        });
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        logger.error("[Autoresearch] Revert failed — state NOT updated", {
+                            error: errorMsg,
+                        });
+                        this.emit("autoresearch:revert-failed", {
+                            tag: state.tag,
+                            targetCommit: state.acceptedCommit,
+                            error: errorMsg,
+                            runCount: state.runCount,
+                        });
+                        this.emitError(state.tag, "REVERT_FAILED", `Failed to revert to ${state.acceptedCommit}. Manual intervention required.`, state.currentPhase, state.runCount);
+                        // Do NOT advance state — repo is in unknown state
+                        throw AutoresearchError.create("REVERT_FAILED", `Failed to revert to ${state.acceptedCommit}. Manual intervention required.`, {
+                            cause: error instanceof Error ? error : undefined,
+                        });
+                    }
+                }
+                // Only reach here if revert succeeded (or no acceptedCommit to revert to)
+                // currentPhase advancement happens unconditionally below via advancePhase("propose")
+                await this.stateStore.update({
+                    runCount: state.runCount + 1,
+                    lastStatus: status,
+                    candidateCommit: null,
+                });
+            }
+            const durationMs = Date.now() - cycleStart;
+            // Set span attributes for the completed cycle
+            span.setAttribute(ATTR.AR_STATUS, status);
+            if (summary.metric !== null) {
+                span.setAttribute(ATTR.AR_METRIC, summary.metric);
+            }
+            span.setAttribute(ATTR.AR_COMMIT, commit);
+            span.setAttribute(ATTR.AR_DURATION_MS, durationMs);
+            logger.info("[Autoresearch] Experiment complete", {
+                status,
+                metric: summary.metric,
+                runCount: state.runCount + 1,
+            });
+            this.emit("autoresearch:experiment-completed", {
+                tag: state.tag,
+                runCount: state.runCount + 1,
+                status,
+                metric: summary.metric,
+                commit,
+                description,
+                durationMs,
+            });
+            // Emit state-updated with final state snapshot
+            const updatedState = await this.stateStore.load();
+            if (updatedState) {
+                this.emit("autoresearch:state-updated", {
+                    tag: updatedState.tag,
+                    phase: updatedState.currentPhase,
+                    runCount: updatedState.runCount,
+                    keepCount: updatedState.keepCount,
+                    bestMetric: updatedState.bestMetric,
+                });
+            }
+            await this.advancePhase("propose");
+            return record;
+        });
+    }
+    /** Get the tools record for use with NeuroLink.generate() */
+    getTools() {
+        return createResearchTools({
+            config: this.config,
+            stateStore: this.stateStore,
+            repoPolicy: this.repoPolicy,
+            runner: this.runner,
+            recorder: this.recorder,
+        });
+    }
+    /** Build system prompt */
+    async getSystemPrompt() {
+        return this.promptCompiler.buildSystemPrompt();
+    }
+    /** Build cycle prompt */
+    async getCyclePrompt() {
+        const state = await this.stateStore.load();
+        if (!state) {
+            throw AutoresearchError.create("STATE_NOT_FOUND", "No state");
+        }
+        const results = await this.recorder.readAll();
+        return this.promptCompiler.buildCyclePrompt(state, results);
+    }
+    /** Get current state */
+    async getState() {
+        return this.stateStore.load();
+    }
+    /** Get results stats */
+    async getStats() {
+        return this.recorder.getStats();
+    }
+    /** Get config */
+    getConfig() {
+        return this.config;
+    }
+    // ── Phase management (Phase 1b/1c) ──────────────────────
+    /**
+     * Single authority for phase transitions.
+     * Persists the new phase to the state store and emits phase-changed event.
+     */
+    async advancePhase(phase) {
+        const currentState = await this.stateStore.load();
+        const fromPhase = currentState?.currentPhase ?? "bootstrap";
+        await this.stateStore.update({ currentPhase: phase });
+        logger.debug("[Autoresearch] Phase advanced", { phase });
+        if (fromPhase !== phase) {
+            this.emit("autoresearch:phase-changed", {
+                from: fromPhase,
+                to: phase,
+                runCount: currentState?.runCount ?? 0,
+                tag: currentState?.tag ?? "",
+            });
+        }
+    }
+    /**
+     * Returns the phase tool policy for the current phase.
+     * Reads the phase from persisted state.
+     */
+    async getPhaseToolPolicy() {
+        const state = await this.stateStore.load();
+        if (!state) {
+            throw AutoresearchError.create("STATE_NOT_FOUND", "No state for getPhaseToolPolicy");
+        }
+        return getPhaseToolPolicy(state.currentPhase);
+    }
+    /**
+     * Returns a tool filter object for the current phase, compatible
+     * with NeuroLink generate()'s toolFilter option.
+     *
+     * Returns { include: string[] } listing only the tools allowed
+     * in the current phase.
+     */
+    async getToolFilterForCurrentPhase() {
+        const policy = await this.getPhaseToolPolicy();
+        return { include: [...policy.activeTools] };
+    }
+    // ── Private helpers ──────────────────────────────────────
+    /** Emit an autoresearch:error event. */
+    emitError(tag, code, message, phase, runCount) {
+        this.emit("autoresearch:error", {
+            tag,
+            error: message,
+            code,
+            phase,
+            runCount,
+        });
+    }
+}
+//# sourceMappingURL=worker.js.map

package/dist/lib/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/lib/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/lib/core/factory.js

@@ -168,7 +168,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
@@ -180,7 +180,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 };
     }
     /**
@@ -192,7 +192,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", {
@@ -226,7 +226,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/lib/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: "CONFIGURATION_ERROR" | "PROVIDER_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?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/lib/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/lib/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,14 +167,14 @@ 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);
 }
 //# sourceMappingURL=providerFactory.js.map

package/dist/lib/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;
     /**