@juspay/neurolink 9.56.2 → 9.57.1

package/dist/lib/evaluation/index.js

@@ -14,7 +14,7 @@ export * from "./pipeline/index.js";
 export * from "./reporting/index.js";
 // Re-export scorers
 export * from "./scorers/index.js";
-// Re-export Factory and Registry (Mastra-inspired patterns)
+// Re-export Factory and Registry
 export { BatchEvaluator } from "./BatchEvaluator.js";
 export { EvaluationAggregator } from "./EvaluationAggregator.js";
 export { EvaluatorFactory, getEvaluatorFactory } from "./EvaluatorFactory.js";

package/dist/lib/index.js

@@ -37,7 +37,7 @@ export { AIProviderFactory };
 export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 // Config Manager export
 export { NeuroLinkConfigManager as ConfigManager } from "./config/configManager.js";
-// Core Infrastructure exports (Mastra-inspired patterns)
+// Core Infrastructure exports (factory + registry patterns)
 export { BaseFactory, BaseRegistry, NeuroLinkFeatureError, createErrorFactory, withRetry, TypedEventEmitter, } from "./core/infrastructure/index.js";
 // ============================================================================
 // CLIENT SDK EXPORTS - Type-safe API access for browser and Node.js
@@ -107,6 +107,23 @@ export { SpanSerializer } from "./observability/utils/spanSerializer.js";
 // Middleware exports
 // Version
 export const VERSION = "1.0.0";
+// ============================================================================
+// Dynamic Arguments
+// ============================================================================
+//
+// Dynamic arguments let you pass functions instead of static values to
+// generate() and stream(). Resolution happens automatically before
+// provider dispatch. Pass dynamicContext inline for per-request
+// user/tenant/session context that dynamic functions can read.
+//
+// Example:
+//   await neurolink.generate({
+//     input: { text: "Hello" },
+//     model: (ctx) => ctx.requestContext.tenant?.plan === "enterprise"
+//       ? "gpt-4o" : "gpt-4o-mini",
+//     dynamicContext: { tenant: { id: "t1", plan: "enterprise" } },
+//   });
+// ============================================================================
 /**
  * Quick start factory function for creating AI provider instances.
  *
@@ -348,7 +365,7 @@ export async function getTelemetryStatus() {
 export { 
 // Main Evaluator
 Evaluator, 
-// Factory and Registry (Mastra-inspired patterns)
+// Factory and Registry
 EvaluationAggregator, EvaluatorFactory, getEvaluatorFactory, getEvaluatorRegistry, 
 // Error utilities
 evaluationErrors, isRetryableEvaluationError, isEvaluationError, createEvaluationFailedError, createParseError, createStrategyNotFoundError, createProviderError, createMaxRetriesExceededError, createBatchEvaluationError, createConfigurationError, contextToErrorContext, 

package/dist/lib/mcp/mcpServerBase.d.ts

@@ -4,7 +4,7 @@
  * Abstract base class for creating custom MCP servers with consistent patterns
  * for tool registration, execution, and lifecycle management.
  *
- * Implements Mastra-style MCPServerBase features including:
+ * Implements MCPServerBase features including:
  * - Tool annotation support (readOnlyHint, destructiveHint, idempotentHint)
  * - Lifecycle hooks (onInit, onStart, onStop)
  * - Event emission for tool operations

package/dist/lib/mcp/mcpServerBase.js

@@ -4,7 +4,7 @@
  * Abstract base class for creating custom MCP servers with consistent patterns
  * for tool registration, execution, and lifecycle management.
  *
- * Implements Mastra-style MCPServerBase features including:
+ * Implements MCPServerBase features including:
  * - Tool annotation support (readOnlyHint, destructiveHint, idempotentHint)
  * - Lifecycle hooks (onInit, onStart, onStop)
  * - Event emission for tool operations

package/dist/lib/neurolink.d.ts

@@ -5,11 +5,12 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, MastraAuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
+import type { DynamicOptions } from "./types/index.js";
 import { TaskManager } from "./tasks/taskManager.js";
 export declare class NeuroLink {
     private mcpInitialized;
@@ -539,7 +540,7 @@ export declare class NeuroLink {
      * @see {@link stream} for streaming generation
      * @since 1.0.0
      */
-    generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
+    generate(optionsOrPrompt: GenerateOptions | DynamicOptions | string): Promise<GenerateResult>;
     private executeGenerateWithMetricsContext;
     private executeGenerateRequest;
     private prepareGenerateRequest;
@@ -695,7 +696,7 @@ export declare class NeuroLink {
      * @throws {Error} When all providers fail to generate content
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
-    stream(options: StreamOptions): Promise<StreamResult>;
+    stream(options: StreamOptions | DynamicOptions): Promise<StreamResult>;
     private executeStreamRequest;
     private validateStreamRequestOptions;
     private maybeHandleWorkflowStreamRequest;
@@ -880,8 +881,12 @@ export declare class NeuroLink {
      * **Generation Events:**
      * - `generation:start` - Fired when text generation begins
      *   - `{ provider: string, timestamp: number }`
-     * - `generation:end` - Fired when text generation completes
-     *   - `{ provider: string, responseTime: number, toolsUsed?: string[], timestamp: number }`
+     * - `generation:end` - Fired when text generation completes (or fails / is aborted)
+     *   - `{ provider: string, responseTime: number, toolsUsed?: string[], timestamp: number, success?: boolean, aborted?: boolean, error?: string }`
+     *   - `success` is `false` for both failures and client aborts; `aborted: true`
+     *     distinguishes the latter so consumers can route cancellations
+     *     differently from real errors. Pipeline B's metrics span maps
+     *     `aborted: true` events to `SpanStatus.WARNING` (not ERROR).
      *
      * **Streaming Events:**
      * - `stream:start` - Fired when streaming begins
@@ -1959,7 +1964,7 @@ export declare class NeuroLink {
     /**
      * Get the currently configured authentication provider
      */
-    getAuthProvider(): MastraAuthProvider | undefined;
+    getAuthProvider(): AuthProvider | undefined;
     /**
      * Lazily initialize the auth provider from pendingAuthConfig.
      * Called on first use (generate/stream with auth token) to avoid
@@ -1993,6 +1998,13 @@ export declare class NeuroLink {
      * @returns The ExternalServerManager instance
      */
     getExternalServerManager(): ExternalServerManager;
+    private buildResolutionContext;
+    /**
+     * Resolve dynamic arguments in GenerateOptions, mutating the options in place.
+     * Only resolves fields that are functions; static values pass through unchanged.
+     */
+    private resolveDynamicOptions;
+    private resolveDynamicFields;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;

package/dist/lib/neurolink.js

@@ -47,6 +47,8 @@ import { ToolRouter } from "./mcp/routing/index.js";
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { inferAnnotations, isSafeToRetry } from "./mcp/toolAnnotations.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
+// Dynamic argument resolution imports
+import { resolveDynamicArgument } from "./dynamic/dynamicResolver.js";
 import { initializeHippocampus } from "./memory/hippocampusInitializer.js";
 import { createMemoryRetrievalTools } from "./memory/memoryRetrievalTools.js";
 import { getMetricsAggregator, MetricsAggregator, } from "./observability/metricsAggregator.js";
@@ -2322,11 +2324,26 @@ Current user's request: ${currentInput}`;
                 if (traceCtx) {
                     span.parentSpanId = traceCtx.parentSpanId;
                 }
-                // Mark failed generations with ERROR status so metrics count them correctly
-                const spanStatus = data.success === false || data.error
-                    ? SpanStatus.ERROR
-                    : SpanStatus.OK;
-                span = SpanSerializer.endSpan(span, spanStatus, data.error ? String(data.error) : undefined);
+                // Mark failed generations with ERROR status so metrics count them
+                // correctly. Client aborts (data.aborted === true) are NOT failures —
+                // they are user-initiated cancellations and must not pollute the
+                // failure rate. Map them to WARNING with the canonical
+                // "Generation aborted by client" message (matches the Langfuse
+                // ContextEnricher mapping for outer/internal generation spans).
+                let spanStatus;
+                let statusMessage;
+                if (data.aborted === true) {
+                    spanStatus = SpanStatus.WARNING;
+                    statusMessage = "Generation aborted by client";
+                }
+                else if (data.success === false || data.error) {
+                    spanStatus = SpanStatus.ERROR;
+                    statusMessage = data.error ? String(data.error) : undefined;
+                }
+                else {
+                    spanStatus = SpanStatus.OK;
+                }
+                span = SpanSerializer.endSpan(span, spanStatus, statusMessage);
                 span.durationMs = responseTime;
                 // G2 fix: Check finishReason and escalate to WARNING for partial failures
                 const finishReason = result?.finishReason ??
@@ -2658,8 +2675,10 @@ Current user's request: ${currentInput}`;
         return metricsTraceContextStorage.run(this.createMetricsTraceContext(), () => this.executeGenerateRequest(optionsOrPrompt, generateSpan));
     }
     async executeGenerateRequest(optionsOrPrompt, generateSpan) {
+        let resolvedOptions;
         try {
             const { options, originalPrompt } = await this.prepareGenerateRequest(optionsOrPrompt, generateSpan);
+            resolvedOptions = options;
             const earlyResult = await this.maybeHandleEarlyGenerateResult(options, generateSpan);
             if (earlyResult) {
                 generateSpan.setStatus({ code: SpanStatusCode.OK });
@@ -2670,17 +2689,29 @@ Current user's request: ${currentInput}`;
             return result;
         }
         catch (error) {
-            generateSpan.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            // Match the inner-span discrimination: client aborts are user-initiated
+            // cancellations, not faults. Mark with finishReason=aborted and skip
+            // ERROR status so ContextEnricher routes the outer trace to
+            // langfuse.level=WARNING (matches Curator telemetry-gaps Issue 5a). All
+            // other errors keep the existing ERROR status + recordException pair.
+            if (isAbortError(error)) {
+                generateSpan.setAttribute("ai.finishReason", "aborted");
+                generateSpan.setAttribute("neurolink.aborted", true);
+            }
+            else {
+                generateSpan.recordException(error instanceof Error ? error : new Error(String(error)));
+                generateSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
             // G7 fix: Distinguish context overflow errors with dedicated attributes
             if (error instanceof ContextBudgetExceededError) {
                 generateSpan.setAttribute("neurolink.error.type", "context_overflow");
                 generateSpan.setAttribute("neurolink.context.estimated_tokens", error.estimatedTokens);
                 generateSpan.setAttribute("neurolink.context.available_tokens", error.availableTokens);
             }
-            this.emitGenerateErrorEvent(optionsOrPrompt, error);
+            this.emitGenerateErrorEvent((resolvedOptions ?? optionsOrPrompt), error);
             throw error;
         }
         finally {
@@ -2693,6 +2724,8 @@ Current user's request: ${currentInput}`;
         const options = typeof optionsOrPrompt === "string"
             ? { input: { text: optionsOrPrompt } }
             : { ...optionsOrPrompt };
+        // Dynamic argument resolution — resolve any function-valued options before downstream use
+        await this.resolveDynamicOptions(options);
         options.model = resolveModel(options.model, this.modelAliasConfig);
         this._disableToolCacheForCurrentRequest = !!options.disableToolCache;
         generateSpan.setAttribute("neurolink.provider", options.provider || "default");
@@ -2839,6 +2872,7 @@ Current user's request: ${currentInput}`;
             maxSteps: options.maxSteps,
             toolChoice: options.toolChoice,
             prepareStep: options.prepareStep,
+            enabledToolNames: options.enabledToolNames,
             enableAnalytics: options.enableAnalytics,
             enableEvaluation: options.enableEvaluation,
             context: options.context,
@@ -2965,6 +2999,11 @@ Current user's request: ${currentInput}`;
         const errModel = typeof optionsOrPrompt === "object"
             ? optionsOrPrompt.model || "unknown"
             : "unknown";
+        // Distinguish client aborts from real failures so consumers (and Langfuse)
+        // can route them differently. `aborted: true` is additive — `success`
+        // remains false for backwards-compat with existing listeners that only
+        // branch on the boolean.
+        const aborted = isAbortError(error);
         try {
             this.emitter.emit("generation:end", {
                 provider: errProvider,
@@ -2972,6 +3011,7 @@ Current user's request: ${currentInput}`;
                 responseTime: 0,
                 error: error instanceof Error ? error.message : String(error),
                 success: false,
+                aborted,
             });
         }
         catch (emitError) {
@@ -3319,10 +3359,23 @@ Current user's request: ${currentInput}`;
             return await this.runGenerateTextInternalFlow(options, internalSpan, context);
         }
         catch (error) {
-            internalSpan.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            // Client aborts are user-initiated cancellations, not system faults.
+            // Setting status=ERROR forces Langfuse to level=ERROR (see
+            // ContextEnricher.onEnd → instrumentation.ts:691). Instead leave status
+            // unset and stamp ai.finishReason=aborted so applyNonErrorLangfuseLevel
+            // maps it to level=WARNING with the canonical "Generation aborted by
+            // client" status_message. Matches Curator telemetry-gaps Issue 5a.
+            if (isAbortError(error)) {
+                internalSpan.setAttribute("ai.finishReason", "aborted");
+                internalSpan.setAttribute("neurolink.aborted", true);
+            }
+            else {
+                internalSpan.recordException(error instanceof Error ? error : new Error(String(error)));
+                internalSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
             throw error;
         }
         finally {
@@ -3378,6 +3431,13 @@ Current user's request: ${currentInput}`;
             if (recoveredResult) {
                 return recoveredResult;
             }
+            // Convert raw DOMException AbortErrors (and other untyped abort shapes)
+            // into NeuroLinkError(ABORT) so callers can branch on
+            // `error.category === ErrorCategory.ABORT` instead of message matching.
+            // Skipped if the error is already a typed abort to avoid double-wrap.
+            if (isAbortError(error) && !(error instanceof NeuroLinkError)) {
+                throw ErrorFactory.aborted(error instanceof Error ? error : new Error(String(error)));
+            }
             throw error;
         }
     }
@@ -3435,28 +3495,24 @@ Current user's request: ${currentInput}`;
             return recoveredResult;
         }
         if (isAbortError(error)) {
-            logger.info(`[${context.functionTag}] Generation aborted — storing conversation turn for title generation`, {
+            // Aborted generations DO NOT write to conversation memory.
+            // Fabricating an assistant turn out of an error condition (the previous
+            // "[generation was interrupted]" sentinel) pollutes the next prompt and
+            // — at the right shape — causes the model to echo the sentinel as its
+            // response. See Curator SI-069 / SI-071. Aborts are signalled to
+            // callers via the thrown error and the "error" emitter event below;
+            // there is nothing to persist, so persisting nothing is correct.
+            //
+            // Title generation continues to work: it reads the user message of the
+            // first *successful* turn (RedisConversationMemoryManager
+            // .generateConversationTitle) and never required a fabricated assistant
+            // turn — the previous comment claiming otherwise was inaccurate.
+            logger.info(`[${context.functionTag}] Generation aborted — skipping memory write (aborts must not pollute conversation history)`, {
                 hasMemory: !!this.conversationMemory,
                 memoryType: this.conversationMemory?.constructor?.name || "NONE",
                 sessionId: options.context?.sessionId ||
                     "unknown",
             });
-            try {
-                const abortedResult = {
-                    content: "[generation was interrupted]",
-                    provider: options.provider || "unknown",
-                    model: options.model || "unknown",
-                    responseTime: Date.now() - context.generateInternalStartTime,
-                };
-                await withTimeout(storeConversationTurn(this.conversationMemory, options, abortedResult, new Date(context.generateInternalStartTime), context.requestId), 5000);
-            }
-            catch (storeError) {
-                logger.warn(`[${context.functionTag}] Failed to store conversation turn after abort`, {
-                    error: storeError instanceof Error
-                        ? storeError.message
-                        : String(storeError),
-                });
-            }
         }
         else {
             logger.error(`[${context.functionTag}] All generation methods failed`, {
@@ -3464,7 +3520,14 @@ Current user's request: ${currentInput}`;
             });
         }
         this.emitter.emit("response:end", "");
-        this.emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
+        // Node EventEmitter rethrows the original error from emit("error", e) if
+        // there is no listener registered, which would short-circuit the caller's
+        // catch block and prevent the abort-typed-error wrap from running. Only
+        // emit when a consumer is listening; non-listening callers receive the
+        // error via the thrown rejection instead, which is the canonical path.
+        if (this.emitter.listenerCount("error") > 0) {
+            this.emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
+        }
         return null;
     }
     async tryRecoverGenerateTextOverflow(options, functionTag, error) {
@@ -4331,13 +4394,18 @@ Current user's request: ${currentInput}`;
      * Used to filter the tool list before building the system prompt.
      */
     applyToolInfoFiltering(tools, options) {
-        if ((!options.toolFilter || options.toolFilter.length === 0) &&
+        // enabledToolNames is an additional whitelist — merged into toolFilter
+        const whitelist = [
+            ...(options.toolFilter ?? []),
+            ...(options.enabledToolNames ?? []),
+        ];
+        if (whitelist.length === 0 &&
             (!options.excludeTools || options.excludeTools.length === 0)) {
             return tools;
         }
         let filtered = tools;
-        if (options.toolFilter && options.toolFilter.length > 0) {
-            const allowSet = new Set(options.toolFilter);
+        if (whitelist.length > 0) {
+            const allowSet = new Set(whitelist);
             filtered = filtered.filter((t) => allowSet.has(t.name));
         }
         if (options.excludeTools && options.excludeTools.length > 0) {
@@ -4493,12 +4561,16 @@ Current user's request: ${currentInput}`;
             disableTools: options.disableTools,
             enableAnalytics: options.enableAnalytics,
             enableEvaluation: options.enableEvaluation,
-            contextKeys: options.context ? Object.keys(options.context) : [],
+            contextKeys: options.context
+                ? Object.keys(options.context ?? {})
+                : [],
             optionKeys: Object.keys(options),
         });
         return metricsTraceContextStorage.run(this.createMetricsTraceContext(), () => this.executeStreamRequest({ ...options }));
     }
     async executeStreamRequest(options) {
+        // Dynamic argument resolution — resolve any function-valued options before downstream use
+        await this.resolveDynamicOptions(options);
         const streamSpan = tracers.sdk.startSpan("neurolink.stream", {
             kind: SpanKind.INTERNAL,
             attributes: {
@@ -5685,8 +5757,12 @@ Current user's request: ${currentInput}`;
      * **Generation Events:**
      * - `generation:start` - Fired when text generation begins
      *   - `{ provider: string, timestamp: number }`
-     * - `generation:end` - Fired when text generation completes
-     *   - `{ provider: string, responseTime: number, toolsUsed?: string[], timestamp: number }`
+     * - `generation:end` - Fired when text generation completes (or fails / is aborted)
+     *   - `{ provider: string, responseTime: number, toolsUsed?: string[], timestamp: number, success?: boolean, aborted?: boolean, error?: string }`
+     *   - `success` is `false` for both failures and client aborts; `aborted: true`
+     *     distinguishes the latter so consumers can route cancellations
+     *     differently from real errors. Pipeline B's metrics span maps
+     *     `aborted: true` events to `SpanStatus.WARNING` (not ERROR).
      *
      * **Streaming Events:**
      * - `stream:start` - Fired when streaming begins
@@ -6627,7 +6703,13 @@ Current user's request: ${currentInput}`;
         prepared.metrics.errorCategories[category] =
             (prepared.metrics.errorCategories[category] || 0) + 1;
         this.emitToolEndEvent(toolName, executionContext.executionStartTime, false, undefined, structuredError);
-        this.emitter.emit("error", structuredError);
+        // Gate on listenerCount: Node EventEmitter rethrows the original error
+        // from emit("error", e) when no listener is registered, which would
+        // short-circuit the surrounding flow and surface as an unhandled
+        // rejection. Same pattern as handleGenerateTextInternalFailure.
+        if (this.emitter.listenerCount("error") > 0) {
+            this.emitter.emit("error", structuredError);
+        }
         structuredError = new NeuroLinkError({
             ...structuredError,
             context: {
@@ -6790,13 +6872,19 @@ Current user's request: ${currentInput}`;
                     result.success === false) {
                     const errorMessage = result.error || "Tool execution failed";
                     const errorToEmit = new Error(errorMessage);
-                    this.emitter.emit("error", errorToEmit);
+                    // Gate on listenerCount — see handleGenerateTextInternalFailure for
+                    // the rationale (Node EventEmitter rethrows on no listener).
+                    if (this.emitter.listenerCount("error") > 0) {
+                        this.emitter.emit("error", errorToEmit);
+                    }
                 }
                 return result;
             }
             catch (error) {
                 const errorToEmit = error instanceof Error ? error : new Error(String(error));
-                this.emitter.emit("error", errorToEmit);
+                if (this.emitter.listenerCount("error") > 0) {
+                    this.emitter.emit("error", errorToEmit);
+                }
                 // Check if tool was not found
                 if (error instanceof Error && error.message.includes("not found")) {
                     const availableTools = await this.getAllAvailableTools();
@@ -8974,7 +9062,7 @@ Current user's request: ${currentInput}`;
     async initializeAuthProviderFromConfig(config) {
         let provider;
         let providerType;
-        // Duck-type check: direct MastraAuthProvider instance
+        // Duck-type check: direct AuthProvider instance
         if ("authenticateToken" in config &&
             typeof config.authenticateToken === "function") {
             provider = config;
@@ -9075,6 +9163,63 @@ Current user's request: ${currentInput}`;
     getExternalServerManager() {
         return this.externalServerManager;
     }
+    // ==========================================================================
+    // Dynamic Argument Resolution
+    // ==========================================================================
+    buildResolutionContext(signal, inlineContext) {
+        return {
+            requestContext: inlineContext || {},
+            signal,
+        };
+    }
+    /**
+     * Resolve dynamic arguments in GenerateOptions, mutating the options in place.
+     * Only resolves fields that are functions; static values pass through unchanged.
+     */
+    async resolveDynamicOptions(options) {
+        const dynamicFields = [
+            "model",
+            "provider",
+            "temperature",
+            "maxTokens",
+            "systemPrompt",
+            "timeout",
+            "thinkingLevel",
+            "disableTools",
+            "enableAnalytics",
+            "enableEvaluation",
+        ];
+        const hasDynamic = dynamicFields.some((f) => typeof options[f] === "function") ||
+            typeof options.tools === "function";
+        if (!hasDynamic) {
+            return;
+        }
+        const inlineCtx = options.dynamicContext;
+        await this.resolveDynamicFields(options, dynamicFields, inlineCtx);
+    }
+    async resolveDynamicFields(options, dynamicFields, inlineContext) {
+        const resolutionContext = this.buildResolutionContext(options.abortSignal, inlineContext);
+        logger.debug("[NeuroLink] Resolving dynamic arguments");
+        await Promise.all(dynamicFields.map(async (field) => {
+            if (typeof options[field] === "function") {
+                const result = await resolveDynamicArgument(options[field], resolutionContext);
+                options[field] = result.value;
+                logger.debug(`[NeuroLink] Resolved dynamic ${field}: ${result.resolutionType}`);
+            }
+        }));
+        // Handle dynamic tools → enabledToolNames mapping.
+        // Per DynamicOptions.tools: DynamicArgument<string[]>, the resolver
+        // must return an array of tool names. Anything else is a contract
+        // violation — fail fast rather than silently disabling tooling.
+        if (typeof options.tools === "function") {
+            const result = await resolveDynamicArgument(options.tools, resolutionContext);
+            if (!Array.isArray(result.value)) {
+                throw new TypeError(`Dynamic tools resolver must return string[] (tool names), got ${typeof result.value === "object" ? "object" : typeof result.value}`);
+            }
+            options.enabledToolNames = result.value;
+            delete options.tools;
+        }
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/lib/observability/exporters/baseExporter.d.ts

@@ -1,6 +1,6 @@
 /**
  * Abstract base class for all observability exporters
- * Follows NeuroLink's factory pattern and Mastra's unified exporter interface
+ * Follows NeuroLink's factory pattern with a unified exporter interface
  */
 import type { ExporterConfig, ExporterHealthStatus, ExportResult, SpanData } from "../../types/index.js";
 /**

package/dist/lib/observability/exporters/baseExporter.js

@@ -1,6 +1,6 @@
 /**
  * Abstract base class for all observability exporters
- * Follows NeuroLink's factory pattern and Mastra's unified exporter interface
+ * Follows NeuroLink's factory pattern with a unified exporter interface
  */
 import { logger } from "../../utils/logger.js";
 /**

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

@@ -490,7 +490,7 @@ export type PermissionDefinition = {
  */
 export type AuthMiddlewareOptions = {
     /** Auth provider instance */
-    provider: MastraAuthProvider;
+    provider: AuthProvider;
     /** Routes to exclude from authentication */
     excludePaths?: string[];
     /** Whether auth is optional (continue if no token) */
@@ -729,7 +729,7 @@ export type CustomAuthConfig = {
     createSession?: (user: AuthUser, context?: AuthRequestContext) => Promise<AuthSession>;
 };
 /**
- * Configuration for MastraAuthProvider.
+ * Configuration for AuthProvider.
  *
  * Discriminated union of base + each provider-specific config so that
  * provider factories receive the properly typed config without requiring
@@ -819,7 +819,7 @@ export type AuthEventHandler = (event: AuthEventData) => void | Promise<void>;
 /**
  * Auth provider factory function type
  */
-export type AuthProviderFactoryFn = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+export type AuthProviderFactoryFn = (config: AuthProviderConfig) => Promise<AuthProvider>;
 /**
  * Auth health check result
  */
@@ -973,7 +973,7 @@ export type AuthLifecycle = {
  * Composed from focused sub-types so consumers can depend on only the
  * slice they need (e.g. `AuthTokenValidator` for token-only middleware).
  *
- * Implements Mastra-style auth provider pattern with unified methods for:
+ * Unified auth provider interface covering:
  * - Token validation  (AuthTokenValidator)
  * - User authorization (AuthUserAuthorizer)
  * - Session management (AuthSessionManager)
@@ -981,7 +981,7 @@ export type AuthLifecycle = {
  * - User management    (AuthUserManager)
  * - Lifecycle          (AuthLifecycle)
  */
-export type MastraAuthProvider = AuthTokenValidator & AuthUserAuthorizer & AuthSessionManager & AuthRequestHandler & AuthUserManager & AuthLifecycle & {
+export type AuthProvider = AuthTokenValidator & AuthUserAuthorizer & AuthSessionManager & AuthRequestHandler & AuthUserManager & AuthLifecycle & {
     /** Provider type identifier */
     readonly type: AuthProviderType;
     /** Provider configuration */
@@ -1019,7 +1019,7 @@ export type AuthJWKSCacheEntry = {
     expiresAt: number;
 };
 /** Async constructor for an auth provider given its config. */
-export type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+export type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<AuthProvider>;
 /** Registration row for an auth provider in AuthProviderFactory. */
 export type AuthProviderRegistration = {
     factory: AuthProviderConstructor;

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

@@ -7,7 +7,7 @@ import type { TaskManagerConfig } from "./task.js";
 import type { HITLConfig } from "../types/hitl.js";
 import type { ConversationMemoryConfig } from "./conversation.js";
 import type { ObservabilityConfig } from "./observability.js";
-import type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
+import type { AuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
 import type { NeurolinkCredentials } from "./providers.js";
 /**
  * Main NeuroLink configuration type
@@ -130,8 +130,8 @@ export type MCPEnhancementsConfig = {
 /**
  * Authentication configuration for NeuroLink SDK
  */
-export type NeuroLinkAuthConfig = MastraAuthProvider | {
-    provider: MastraAuthProvider;
+export type NeuroLinkAuthConfig = AuthProvider | {
+    provider: AuthProvider;
 } | {
     type: "auth0";
     config: Auth0Config;
@@ -169,7 +169,7 @@ export type NeuroLinkAuthConfig = MastraAuthProvider | {
 /**
  * Re-export auth types for convenience
  */
-export type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, AuthenticatedContext, };
+export type { AuthProvider, AuthProviderType, AuthProviderConfig, AuthenticatedContext, };
 /**
  * Provider-specific configuration
  */