@juspay/neurolink 9.56.1 → 9.57.0

package/dist/lib/types/scorer.js

@@ -1,6 +1,6 @@
 /**
  * @file Scorer type definitions for NeuroLink evaluation system
- * Mastra-style modular scorer interfaces and types
+ * Modular scorer interfaces and types
  */
 export {};
 //# sourceMappingURL=scorer.js.map

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

@@ -4,7 +4,7 @@
  */
 /**
  * Span types for AI operations
- * Following Mastra's span categorization and OTel GenAI conventions
+ * Following OTel GenAI conventions for span categorization
  */
 export declare enum SpanType {
     /** Agent execution run (reserved for future multi-agent support) */

package/dist/lib/types/span.js

@@ -4,7 +4,7 @@
  */
 /**
  * Span types for AI operations
- * Following Mastra's span categorization and OTel GenAI conventions
+ * Following OTel GenAI conventions for span categorization
  */
 export var SpanType;
 (function (SpanType) {

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

@@ -330,6 +330,12 @@ export type StreamOptions = {
     } | undefined>;
     /** Include only these tools by name (whitelist). If set, only matching tools are available. */
     toolFilter?: string[];
+    /**
+     * Filter available tools by name.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     * Merged into `toolFilter` before tool filtering runs.
+     */
+    enabledToolNames?: string[];
     /** Exclude these tools by name (blacklist). Applied after toolFilter. */
     excludeTools?: string[];
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */

package/dist/lib/utils/fileDetector.d.ts

@@ -43,6 +43,13 @@ export declare class FileDetector {
      * Derive byte size from FileInput for tracing.
      */
     private static deriveInputSize;
+    /**
+     * Classify a FileInput into the FileSource enum used by downstream
+     * loaders. Keeps the mimetype-hint short-circuit in detect() able to
+     * produce a valid FileDetectionResult without re-implementing the
+     * source-inference rules scattered across loadContent().
+     */
+    private static deriveInputSource;
     /**
      * Try fallback parsing for a specific file type
      * Used when file detection returns "unknown" but we want to try parsing anyway

package/dist/lib/utils/fileDetector.js

@@ -23,6 +23,7 @@ import { tracers, ATTR, withSpan } from "../telemetry/index.js";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
 import { logger } from "./logger.js";
+import { mimeHintToExtension, mimeHintToFileType, normalizeMimeHint, } from "./mimeTypeHints.js";
 import { PDFProcessor } from "./pdfProcessor.js";
 /**
  * Default retry configuration constants
@@ -320,6 +321,27 @@ export class FileDetector {
         }
         return 0;
     }
+    /**
+     * Classify a FileInput into the FileSource enum used by downstream
+     * loaders. Keeps the mimetype-hint short-circuit in detect() able to
+     * produce a valid FileDetectionResult without re-implementing the
+     * source-inference rules scattered across loadContent().
+     */
+    static deriveInputSource(input) {
+        if (Buffer.isBuffer(input)) {
+            return "buffer";
+        }
+        if (typeof input === "string") {
+            if (input.startsWith("data:")) {
+                return "datauri";
+            }
+            if (input.startsWith("http://") || input.startsWith("https://")) {
+                return "url";
+            }
+            return "path";
+        }
+        return "buffer";
+    }
     /**
      * Try fallback parsing for a specific file type
      * Used when file detection returns "unknown" but we want to try parsing anyway
@@ -520,6 +542,31 @@ export class FileDetector {
      * Stops at first strategy with confidence >= threshold (default: 80%)
      */
     static async detect(input, options) {
+        // Short-circuit on a trustworthy caller-provided mimetype hint. This is
+        // the eager-path counterpart to FileReferenceRegistry.register()'s hint
+        // handling — necessary for tiny files (<= TINY_MAX) that skip the lazy
+        // registry path. normalizeMimeHint drops "application/octet-stream" so a
+        // caller cannot hide real content behind the opaque sentinel.
+        const hintMime = normalizeMimeHint(options?.mimetypeHint);
+        if (hintMime) {
+            const type = mimeHintToFileType(hintMime);
+            if (type) {
+                const ext = mimeHintToExtension(hintMime);
+                const result = {
+                    type,
+                    mimeType: hintMime,
+                    extension: ext || null,
+                    source: FileDetector.deriveInputSource(input),
+                    metadata: {
+                        confidence: 95,
+                        filename: FileDetector.deriveInputFilename(input),
+                        size: FileDetector.deriveInputSize(input),
+                    },
+                };
+                logger.info(`[FileDetector] Type: ${type} (95%, from mimetype hint: ${hintMime})`);
+                return result;
+            }
+        }
         const confidenceThreshold = options?.confidenceThreshold ?? 80;
         const strategies = [
             new MagicBytesStrategy(),

package/dist/lib/utils/messageBuilder.js

@@ -554,6 +554,7 @@ export async function buildMessagesArray(options) {
                         maxSize: 50 * 1024 * 1024,
                         allowedTypes: ["csv"],
                         csvOptions: csvOptions,
+                        mimetypeHint: isFileWithMetadata(file) ? file.mimetype : undefined,
                     });
                     if (result.type === "csv") {
                         let csvSection = `\n\n## CSV Data from "${filename}":\n`;
@@ -806,6 +807,12 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
                 // ─── Full processing path (current behavior) ──────────────────
                 const genericFileMaxSize = Math.max(maxSize, 100 * 1024 * 1024);
                 const rawFileInput = isFileWithMetadata(file) ? file.buffer : file;
+                // Forward the caller's mimetype hint (Slack/Curator-style
+                // extension-less buffers) so the eager path classifies correctly
+                // for tiny files — the lazy registry path has its own hint wiring.
+                const fileMimetypeHint = isFileWithMetadata(file)
+                    ? file.mimetype
+                    : undefined;
                 const result = await FileDetector.detectAndProcess(rawFileInput, {
                     maxSize: genericFileMaxSize,
                     allowedTypes: [
@@ -824,6 +831,7 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
                     ],
                     csvOptions: options.csvOptions,
                     provider: provider,
+                    mimetypeHint: fileMimetypeHint,
                 });
                 appendDetectedFileResult(result, file, options);
                 includedCount++;
@@ -1658,7 +1666,13 @@ async function tryRegisterFileReference(file, fileSize, registry, index = 0) {
             return false;
         }
         const filename = extractFilename(file, index);
-        await registry.register(buffer, getFileSource(file), { filename });
+        const mimetype = typeof file === "object" && !Buffer.isBuffer(file)
+            ? file.mimetype
+            : undefined;
+        await registry.register(buffer, getFileSource(file), {
+            filename,
+            mimetype,
+        });
         logger.info(`[FileDetector] Registered "${filename}" (${(fileSize / 1024).toFixed(0)} KB) ` +
             `as lazy reference — skipping upfront processing`);
         return true;

package/dist/lib/utils/mimeTypeHints.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared helpers for caller-provided MIME type hints.
+ *
+ * A "MIME hint" is a mimetype string the SDK receives alongside a raw Buffer
+ * whose original filename is missing (e.g. Slack/Curator file-uploads that
+ * arrive as { buffer, filename: "Untitled", mimetype: "text/plain" }). When
+ * the filename has no extension and magic-byte detection cannot identify the
+ * content, the hint is the only signal we have.
+ *
+ * Both FileReferenceRegistry.register() and FileDetector.detect() consume
+ * these helpers so the trust/normalization rules stay in one place:
+ *
+ *   - `application/octet-stream` is never trusted — it is the opaque
+ *     "I don't know" sentinel and would let a caller hide real content
+ *     behind a generic label (a PNG hinted as octet-stream would otherwise
+ *     record mimeType="application/octet-stream" instead of "image/png").
+ *   - Empty/undefined hints pass through as `undefined`.
+ *   - A hint that cannot be classified maps to `null` so the caller falls
+ *     back to magic-byte / extension detection instead of synthesising a
+ *     wrong type.
+ */
+import type { FileType } from "../types/index.js";
+/**
+ * Normalize a caller-provided mimetype hint: strip any `;charset=...`
+ * parameter, lowercase, trim. Returns undefined for empty strings or for
+ * the opaque `application/octet-stream` sentinel so downstream code can
+ * treat the hint as absent instead of trusting it verbatim.
+ */
+export declare function normalizeMimeHint(raw?: string): string | undefined;
+/**
+ * Map a normalized mimetype hint to a NeuroLink FileType. Returns null when
+ * the mimetype is unknown or too generic to classify confidently.
+ */
+export declare function mimeHintToFileType(mimetype: string): FileType | null;
+/**
+ * Map a normalized mimetype hint to the canonical file extension (without
+ * leading dot). Returns "" when the mimetype is unknown — caller should
+ * then fall back to magic-byte detection.
+ */
+export declare function mimeHintToExtension(mimetype: string): string;

package/dist/lib/utils/mimeTypeHints.js

@@ -0,0 +1,122 @@
+const OPAQUE_MIMETYPE = "application/octet-stream";
+/**
+ * Normalize a caller-provided mimetype hint: strip any `;charset=...`
+ * parameter, lowercase, trim. Returns undefined for empty strings or for
+ * the opaque `application/octet-stream` sentinel so downstream code can
+ * treat the hint as absent instead of trusting it verbatim.
+ */
+export function normalizeMimeHint(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    const cleaned = raw.split(";")[0].trim().toLowerCase();
+    if (!cleaned || cleaned === OPAQUE_MIMETYPE) {
+        return undefined;
+    }
+    return cleaned;
+}
+/**
+ * Map a normalized mimetype hint to a NeuroLink FileType. Returns null when
+ * the mimetype is unknown or too generic to classify confidently.
+ */
+export function mimeHintToFileType(mimetype) {
+    const exact = {
+        "text/csv": "csv",
+        "application/csv": "csv",
+        "image/svg+xml": "svg",
+        "application/pdf": "pdf",
+        "application/json": "text",
+        "application/xml": "text",
+        "text/xml": "text",
+        "application/yaml": "text",
+        "application/x-yaml": "text",
+        "text/yaml": "text",
+        "application/javascript": "text",
+        "application/typescript": "text",
+        "application/zip": "archive",
+        "application/x-tar": "archive",
+        "application/gzip": "archive",
+        "application/x-gzip": "archive",
+        "application/x-7z-compressed": "archive",
+        "application/vnd.rar": "archive",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    };
+    if (exact[mimetype]) {
+        return exact[mimetype];
+    }
+    if (mimetype.startsWith("text/")) {
+        return "text";
+    }
+    if (mimetype.startsWith("image/")) {
+        return "image";
+    }
+    if (mimetype.startsWith("audio/")) {
+        return "audio";
+    }
+    if (mimetype.startsWith("video/")) {
+        return "video";
+    }
+    return null;
+}
+/**
+ * Map a normalized mimetype hint to the canonical file extension (without
+ * leading dot). Returns "" when the mimetype is unknown — caller should
+ * then fall back to magic-byte detection.
+ */
+export function mimeHintToExtension(mimetype) {
+    const table = {
+        // Text
+        "text/plain": "txt",
+        "text/html": "html",
+        "text/css": "css",
+        "text/javascript": "js",
+        "application/javascript": "js",
+        "application/typescript": "ts",
+        "text/markdown": "md",
+        "text/csv": "csv",
+        "application/csv": "csv",
+        "application/json": "json",
+        "application/xml": "xml",
+        "text/xml": "xml",
+        "application/yaml": "yaml",
+        "application/x-yaml": "yaml",
+        "text/yaml": "yaml",
+        // Documents
+        "application/pdf": "pdf",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+        // Images
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/gif": "gif",
+        "image/webp": "webp",
+        "image/bmp": "bmp",
+        "image/tiff": "tiff",
+        "image/svg+xml": "svg",
+        // Video
+        "video/mp4": "mp4",
+        "video/webm": "webm",
+        "video/quicktime": "mov",
+        "video/x-matroska": "mkv",
+        "video/x-msvideo": "avi",
+        // Audio
+        "audio/mpeg": "mp3",
+        "audio/wav": "wav",
+        "audio/ogg": "ogg",
+        "audio/flac": "flac",
+        "audio/mp4": "m4a",
+        "audio/aac": "aac",
+        // Archives
+        "application/zip": "zip",
+        "application/x-tar": "tar",
+        "application/gzip": "gz",
+        "application/x-gzip": "gz",
+        "application/x-7z-compressed": "7z",
+        "application/vnd.rar": "rar",
+    };
+    return table[mimetype] || "";
+}
+//# sourceMappingURL=mimeTypeHints.js.map

package/dist/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/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/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;
@@ -1959,7 +1960,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 +1994,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/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";
@@ -2658,8 +2660,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 });
@@ -2680,7 +2684,7 @@ Current user's request: ${currentInput}`;
                 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 +2697,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 +2845,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,
@@ -4331,13 +4338,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 +4505,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: {
@@ -8974,7 +8990,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 +9091,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/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/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/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;