@juspay/neurolink 9.41.0 → 9.42.0

package/dist/tasks/taskManager.js

@@ -70,15 +70,35 @@ export class TaskManager {
             store: this.store.type,
         });
     }
+    getStore() {
+        if (!this.store) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Store not initialized. Call initialize() first.");
+        }
+        return this.store;
+    }
+    getBackend() {
+        if (!this.backend) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Backend not initialized. Call initialize() first.");
+        }
+        return this.backend;
+    }
+    getExecutor() {
+        if (!this.executor) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Executor not initialized. Call initialize() first.");
+        }
+        return this.executor;
+    }
     // ── Public API ────────────────────────────────────────
     async create(definition) {
         if (this.config.enabled === false) {
             throw TaskError.create("TASK_DISABLED", "TaskManager is disabled. Set tasks.enabled to true in config.");
         }
         await this.ensureInitialized();
+        const store = this.getStore();
+        const backend = this.getBackend();
         // Enforce maximum task limit to prevent unbounded task creation
         const maxTasks = this.config.maxTasks ?? TASK_DEFAULTS.maxTasks;
-        const existingTasks = await this.store.list();
+        const existingTasks = await store.list();
         if (existingTasks.length >= maxTasks) {
             throw TaskError.create("TASK_LIMIT_REACHED", `Task limit reached (${maxTasks}). Delete existing tasks or increase maxTasks config.`);
         }
@@ -124,7 +144,7 @@ export class TaskManager {
             task.sessionId = `session_${nanoid(12)}`;
         }
         // Save to store
-        await this.store.save(task);
+        await store.save(task);
         // Register callbacks (in-memory only)
         if (definition.onSuccess || definition.onError || definition.onComplete) {
             this.callbacks.set(task.id, {
@@ -135,10 +155,10 @@ export class TaskManager {
         }
         // Schedule
         try {
-            await this.backend.schedule(task, (t) => this.onTaskTick(t));
+            await backend.schedule(task, (t) => this.onTaskTick(t));
         }
         catch (err) {
-            await this.store.delete(task.id);
+            await store.delete(task.id);
             throw err;
         }
         this.emit("task:created", task);
@@ -152,15 +172,17 @@ export class TaskManager {
     }
     async get(taskId) {
         await this.ensureInitialized();
-        return this.store.get(taskId);
+        return this.getStore().get(taskId);
     }
     async list(filter) {
         await this.ensureInitialized();
-        return this.store.list(filter);
+        return this.getStore().list(filter);
     }
     async update(taskId, updates) {
         await this.ensureInitialized();
-        const existing = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const existing = await store.get(taskId);
         if (!existing) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
@@ -194,21 +216,21 @@ export class TaskManager {
             }
             else if (updates.mode !== "continuation") {
                 taskUpdates.sessionId = undefined;
-                await this.store.clearHistory(taskId);
+                await store.clearHistory(taskId);
             }
         }
-        const updated = await this.store.update(taskId, taskUpdates);
+        const updated = await store.update(taskId, taskUpdates);
         // Re-schedule if schedule changed and task is active
         if (updates.schedule && updated.status === "active") {
-            await this.backend.cancel(taskId);
-            await this.backend.schedule(updated, (t) => this.onTaskTick(t));
+            await backend.cancel(taskId);
+            await backend.schedule(updated, (t) => this.onTaskTick(t));
         }
         return updated;
     }
     /** Run a task immediately (outside of its schedule) */
     async run(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const task = await this.getStore().get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
@@ -216,42 +238,48 @@ export class TaskManager {
     }
     async pause(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const task = await store.get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
         if (task.status !== "active") {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot pause task with status: ${task.status}`);
         }
-        await this.backend.pause(taskId);
-        const updated = await this.store.update(taskId, { status: "paused" });
+        await backend.pause(taskId);
+        const updated = await store.update(taskId, { status: "paused" });
         this.emit("task:paused", updated);
         return updated;
     }
     async resume(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const task = await store.get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
         if (task.status !== "paused") {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot resume task with status: ${task.status}`);
         }
-        const updated = await this.store.update(taskId, { status: "active" });
-        await this.backend.schedule(updated, (t) => this.onTaskTick(t));
+        const updated = await store.update(taskId, { status: "active" });
+        await backend.schedule(updated, (t) => this.onTaskTick(t));
         this.emit("task:resumed", updated);
         return updated;
     }
     async delete(taskId) {
         await this.ensureInitialized();
-        await this.backend.cancel(taskId);
-        await this.store.delete(taskId);
+        const backend = this.getBackend();
+        const store = this.getStore();
+        await backend.cancel(taskId);
+        await store.delete(taskId);
         this.callbacks.delete(taskId);
         this.emit("task:deleted", taskId);
     }
     async runs(taskId, options) {
         await this.ensureInitialized();
-        return this.store.getRuns(taskId, options);
+        return this.getStore().getRuns(taskId, options);
     }
     async shutdown() {
         if (this.backend) {
@@ -279,8 +307,11 @@ export class TaskManager {
      */
     async onTaskTick(task) {
         this.emit("task:started", task);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const executor = this.getExecutor();
         // Re-read latest task state (may have been updated/paused since scheduling)
-        const current = await this.store.get(task.id);
+        const current = await store.get(task.id);
         if (!current || current.status !== "active") {
             logger.debug("[TaskManager] Skipping tick for non-active task", {
                 taskId: task.id,
@@ -295,9 +326,9 @@ export class TaskManager {
                 timestamp: new Date().toISOString(),
             };
         }
-        const result = await this.executor.execute(current);
+        const result = await executor.execute(current);
         // Log the run
-        await this.store.appendRun(task.id, result);
+        await store.appendRun(task.id, result);
         // Update task tracking
         const updates = {
             runCount: current.runCount + 1,
@@ -306,18 +337,18 @@ export class TaskManager {
         // Check if task should complete
         if (current.maxRuns && current.runCount + 1 >= current.maxRuns) {
             updates.status = "completed";
-            await this.backend.cancel(task.id);
+            await backend.cancel(task.id);
         }
         // Mark successful once tasks as completed
         if (result.status === "success" && current.schedule.type === "once") {
             updates.status = "completed";
-            await this.backend.cancel(task.id);
+            await backend.cancel(task.id);
         }
         // Mark as failed on permanent error
         if (result.status === "error" && current.schedule.type === "once") {
             updates.status = "failed";
         }
-        await this.store.update(task.id, updates);
+        await store.update(task.id, updates);
         // Fire callbacks
         const cbs = this.callbacks.get(task.id);
         if (cbs) {
@@ -337,7 +368,7 @@ export class TaskManager {
                     });
                 }
                 if (updates.status === "completed" || updates.status === "failed") {
-                    const finalTask = await this.store.get(task.id);
+                    const finalTask = await store.get(task.id);
                     if (finalTask && cbs.onComplete) {
                         await cbs.onComplete(finalTask);
                     }
@@ -364,10 +395,12 @@ export class TaskManager {
      * Called on initialization to handle process restarts.
      */
     async rescheduleActiveTasks() {
-        const activeTasks = await this.store.list({ status: "active" });
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const activeTasks = await store.list({ status: "active" });
         for (const task of activeTasks) {
             try {
-                await this.backend.schedule(task, (t) => this.onTaskTick(t));
+                await backend.schedule(task, (t) => this.onTaskTick(t));
                 logger.debug("[TaskManager] Re-scheduled task", {
                     taskId: task.id,
                     name: task.name,

package/dist/telemetry/index.d.ts

@@ -4,7 +4,8 @@ export { withSpan, withClientSpan, type SpanOptions } from "./withSpan.js";
 export { ATTR } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export declare function initializeTelemetry(): Promise<import("./telemetryService.js").TelemetryService>;
 /**

package/dist/telemetry/index.js

@@ -6,7 +6,8 @@ export { ATTR } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export async function initializeTelemetry() {
     const { TelemetryService } = await import("./telemetryService.js");

package/dist/telemetry/telemetryService.d.ts

@@ -11,6 +11,7 @@ export declare class TelemetryService {
     private tracerProvider?;
     private enabled;
     private initialized;
+    private usingExternalTracerProvider;
     private meter?;
     private tracer?;
     private aiRequestCounter?;
@@ -29,6 +30,8 @@ export declare class TelemetryService {
     private constructor();
     static getInstance(): TelemetryService;
     private isTelemetryEnabled;
+    private hasExternalTracerProvider;
+    private adoptExternalTracerProvider;
     private initializeTelemetry;
     private initializeMetrics;
     initialize(): Promise<void>;

package/dist/telemetry/telemetryService.js

@@ -9,6 +9,7 @@ export class TelemetryService {
     tracerProvider;
     enabled = false;
     initialized = false;
+    usingExternalTracerProvider = false;
     meter;
     tracer;
     // Optional Metrics (only created when enabled)
@@ -43,11 +44,48 @@ export class TelemetryService {
         return TelemetryService.instance;
     }
     isTelemetryEnabled() {
-        return (process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
+        return (this.hasExternalTracerProvider() ||
+            process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
             process.env.OTEL_EXPORTER_OTLP_ENDPOINT !== undefined);
     }
+    hasExternalTracerProvider() {
+        try {
+            const provider = trace.getTracerProvider();
+            if (!provider) {
+                return false;
+            }
+            const delegateName = provider._delegate?.constructor?.name || "";
+            if (delegateName && delegateName !== "NoopTracerProvider") {
+                return true;
+            }
+            const providerName = provider.constructor?.name || "";
+            return (providerName !== "ProxyTracerProvider" &&
+                providerName !== "NoopTracerProvider");
+        }
+        catch (error) {
+            logger.warn("[Telemetry] Failed checking for external TracerProvider", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    adoptExternalTracerProvider(reason) {
+        this.usingExternalTracerProvider = true;
+        this.tracerProvider = undefined;
+        this.meter = metrics.getMeter("neurolink-ai");
+        this.tracer = trace.getTracer("neurolink-ai");
+        this.initializeMetrics();
+        logger.debug("[Telemetry] Reusing externally managed TracerProvider", {
+            reason,
+            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+        });
+    }
     initializeTelemetry() {
         try {
+            if (this.hasExternalTracerProvider()) {
+                this.adoptExternalTracerProvider("global tracer provider already registered");
+                return;
+            }
             const resource = resourceFromAttributes({
                 [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
                 [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
@@ -61,13 +99,23 @@ export class TelemetryService {
                 resource,
                 spanProcessors: [new BatchSpanProcessor(exporter)],
             });
-            trace.setGlobalTracerProvider(this.tracerProvider);
             this.meter = metrics.getMeter("neurolink-ai");
-            this.tracer = trace.getTracer("neurolink-ai");
+            this.tracer = this.tracerProvider.getTracer("neurolink-ai");
             this.initializeMetrics();
-            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+            logger.debug("[Telemetry] Initialized local telemetry exporter", {
+                endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+                globalTracerProviderOwnedBy: "observability/instrumentation",
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isDuplicateRegistration = errorMessage.includes("duplicate registration") ||
+                errorMessage.includes("already registered") ||
+                errorMessage.includes("already set");
+            if (isDuplicateRegistration && this.hasExternalTracerProvider()) {
+                this.adoptExternalTracerProvider("duplicate global tracer registration detected");
+                return;
+            }
             logger.error("[Telemetry] Failed to initialize:", error);
             this.enabled = false;
         }
@@ -105,6 +153,16 @@ export class TelemetryService {
         if (!this.enabled) {
             return;
         }
+        if (this.usingExternalTracerProvider) {
+            this.initialized = true;
+            logger.debug("[Telemetry] External TracerProvider already initialized by host");
+            return;
+        }
+        if (!this.tracerProvider) {
+            this.initialized = true;
+            logger.debug("[Telemetry] Tracer provider already prepared during constructor");
+            return;
+        }
         try {
             // Register AsyncLocalStorage context manager for proper parent-child
             // span relationships across async boundaries (required for startActiveSpan)
@@ -308,7 +366,9 @@ export class TelemetryService {
     }
     // Cleanup
     async shutdown() {
-        if (this.enabled && this.tracerProvider) {
+        if (this.enabled &&
+            this.tracerProvider &&
+            !this.usingExternalTracerProvider) {
             try {
                 await this.tracerProvider.shutdown();
                 this.initialized = false;

package/dist/types/cli.d.ts

@@ -763,6 +763,8 @@ export type ProxyStartArgs = {
     quiet?: boolean;
     debug?: boolean;
     config?: string;
+    envFile?: string;
+    passthrough?: boolean;
 };
 /** Arguments accepted by `neurolink proxy status` */
 export type ProxyStatusArgs = {
@@ -779,6 +781,11 @@ export type ProxyGuardArgs = {
     pollIntervalMs?: number;
     quiet?: boolean;
 };
+/** Arguments accepted by `neurolink proxy telemetry <subcommand>` */
+export type ProxyTelemetryArgs = {
+    action?: "setup" | "start" | "stop" | "status" | "logs" | "import-dashboard";
+    quiet?: boolean;
+};
 /** A fallback chain entry (serialisable subset of FallbackEntry) */
 export type FallbackInfo = {
     provider: string;
@@ -791,12 +798,15 @@ export type ProxyState = {
     host: string;
     strategy: string;
     startTime: string;
+    envFile?: string;
     /** Fallback chain from proxy config (persisted at start time) */
     fallbackChain?: FallbackInfo[];
     /** Optional fail-open guard PID that reverts Claude settings if proxy dies */
     guardPid?: number;
     /** How the proxy was launched — "launchd" if installed as service, "manual" otherwise */
     managedBy?: "launchd" | "manual";
+    /** Whether the proxy is running in transparent passthrough mode */
+    passthrough?: boolean;
 };
 /** Stored credentials for an authenticated provider. */
 export type StoredCredentials = {

package/dist/types/proxyTypes.d.ts

@@ -239,10 +239,11 @@ export type ParsedClaudeRequest = {
         role: string;
         content: string;
     }>;
-    /** Tools in NeuroLink-compatible shape (name -> { description, parameters }). */
+    /** Tools translated to AI SDK-compatible shape for provider fallback. */
     tools: Record<string, {
-        description: string;
-        parameters: Record<string, unknown>;
+        description?: string;
+        inputSchema?: unknown;
+        execute?: (...args: unknown[]) => unknown;
     }>;
     /**
      * Tool choice mapping from Claude format.
@@ -421,21 +422,52 @@ export type RequestLogEntry = {
     errorMessage?: string;
     inputTokens?: number;
     outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    /** OTel trace ID for correlation with distributed traces */
+    traceId?: string;
+    /** OTel span ID for correlation with distributed traces */
+    spanId?: string;
+};
+export type RequestAttemptLogEntry = {
+    timestamp: string;
+    requestId: string;
+    attempt: number;
+    method: string;
+    path: string;
+    model: string;
+    stream: boolean;
+    toolCount: number;
+    account: string;
+    accountType: string;
+    responseStatus: number;
+    responseTimeMs: number;
+    errorType?: string;
+    errorMessage?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    /** OTel trace ID for correlation with distributed traces */
+    traceId?: string;
+    /** OTel span ID for correlation with distributed traces */
+    spanId?: string;
 };
 export type AccountStats = {
     label: string;
     type: string;
-    requestCount: number;
+    attemptCount: number;
     successCount: number;
     errorCount: number;
     rateLimitCount: number;
-    lastRequestAt: number;
+    lastAttemptAt: number;
     lastErrorAt?: number;
     currentBackoffLevel: number;
     coolingUntil?: number;
 };
 export type ProxyStats = {
     startedAt: number;
+    totalAttempts: number;
     totalRequests: number;
     totalSuccess: number;
     totalErrors: number;

package/dist/types/streamTypes.d.ts

@@ -1,16 +1,16 @@
-import type { Tool } from "ai";
+import type { LanguageModel, StepResult, Tool, ToolChoice } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { RAGConfig } from "../rag/types.js";
 import type { AnalyticsData, ToolExecutionEvent, ToolExecutionSummary } from "../types/index.js";
-import type { MiddlewareFactoryOptions, OnFinishCallback, OnErrorCallback, OnChunkCallback } from "../types/middlewareTypes.js";
+import type { MiddlewareFactoryOptions, OnChunkCallback, OnErrorCallback, OnFinishCallback } from "../types/middlewareTypes.js";
 import type { TokenUsage } from "./analytics.js";
 import type { JsonValue, UnknownRecord } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { ChatMessage } from "./conversation.js";
+import type { AdditionalMemoryUser } from "./generateTypes.js";
 import type { AIModelProviderConfig } from "./providers.js";
 import type { TTSChunk, TTSOptions } from "./ttsTypes.js";
-import type { AdditionalMemoryUser } from "./generateTypes.js";
 import type { StandardRecord, ValidationSchema } from "./typeAliases.js";
 /**
  * Progress tracking and metadata for streaming operations
@@ -326,12 +326,34 @@ export type StreamOptions = {
     abortSignal?: AbortSignal;
     disableTools?: boolean;
     maxSteps?: number;
+    /**
+     * Tool choice configuration for streaming generation.
+     * Mirrors generate() so translated/fallback requests can preserve forced tool use.
+     */
+    toolChoice?: ToolChoice<Record<string, Tool>>;
+    /**
+     * Optional callback that runs before each stream step in a multi-step generation.
+     */
+    prepareStep?: (options: {
+        steps: StepResult<Record<string, Tool>>[];
+        stepNumber: number;
+        maxSteps: number;
+        model: LanguageModel;
+    }) => PromiseLike<{
+        toolChoice?: ToolChoice<Record<string, Tool>>;
+        activeTools?: Record<string, Tool>;
+    } | undefined>;
     /** Include only these tools by name (whitelist). If set, only matching tools are available. */
     toolFilter?: string[];
     /** Exclude these tools by name (blacklist). Applied after toolFilter. */
     excludeTools?: string[];
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */
     disableToolCache?: boolean;
+    /**
+     * Disable NeuroLink's internal provider fallback for this request.
+     * Used by the Claude proxy so the proxy itself can own fallback order.
+     */
+    disableInternalFallback?: boolean;
     /**
      * Skip injecting tool schemas into the system prompt.
      * When true, tools are ONLY passed natively via the provider's `tools` parameter,

package/dist/utils/messageBuilder.js

@@ -775,6 +775,7 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
         return;
     }
     const totalFiles = options.input.files.length;
+    const files = options.input.files;
     return withSpan({
         name: "neurolink.file.process_all",
         tracer: tracers.file,
@@ -787,8 +788,8 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
         options.input.text = options.input.text || "";
         let includedCount = 0;
         const fileRegistry = options.fileRegistry;
-        for (let fileIdx = 0; fileIdx < options.input.files.length; fileIdx++) {
-            const file = options.input.files[fileIdx];
+        for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+            const file = files[fileIdx];
             const filename = extractFilename(file, fileIdx);
             try {
                 // ─── Lazy file registration path ──────────────────────────────

package/dist/utils/providerHealth.d.ts

@@ -98,6 +98,20 @@ export declare class ProviderHealthChecker {
      * Check Azure OpenAI configuration
      */
     private static checkAzureConfig;
+    private static getLiteLLMBaseUrl;
+    private static getLiteLLMModelsUrl;
+    private static getConfiguredLiteLLMModel;
+    private static getOllamaBaseUrl;
+    private static getOllamaTagsUrl;
+    private static getConfiguredOllamaModel;
+    private static fetchJsonWithTimeout;
+    private static normalizeModelList;
+    private static hasRequestedModel;
+    private static getOllamaAvailableModels;
+    private static getLiteLLMAvailableModels;
+    private static checkOllamaAvailability;
+    private static checkLiteLLMAvailability;
+    private static checkLiteLLMConfig;
     /**
      * Check Ollama configuration
      */
@@ -169,6 +183,10 @@ export declare class ProviderHealthChecker {
      * Clear health cache for a provider or all providers
      */
     static clearHealthCache(providerName?: AIProviderName): void;
+    static checkFallbackProviderAvailability(providerName: string, model: string): Promise<{
+        available: boolean;
+        reason?: string;
+    }>;
     /**
      * Get the best healthy provider from a list of options (NON-BLOCKING)
      * Prioritizes healthy providers over configured but unhealthy ones