@juspay/neurolink 9.56.1 → 9.57.0

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

package/dist/types/dynamic.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Dynamic Arguments Type Definitions
+ *
+ * Pass functions instead of static values to generate() and stream().
+ * Functions are resolved at runtime before provider dispatch.
+ *
+ * @module types/dynamic
+ */
+import type { AIProviderName } from "../constants/enums.js";
+/**
+ * Context passed to context-aware dynamic argument functions.
+ * `requestContext` is whatever the consumer passed as `dynamicContext` —
+ * NeuroLink does not prescribe its shape.
+ */
+export type DynamicResolutionContext = {
+    /** Consumer-provided context (any shape) */
+    requestContext: Record<string, unknown>;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+};
+/**
+ * A value that can be static, a function, or a context-aware function.
+ *
+ * @example
+ * ```typescript
+ * // Static
+ * model: "gpt-4o"
+ *
+ * // Function
+ * model: () => process.env.MODEL || "gpt-4o"
+ *
+ * // Context-aware
+ * model: (ctx) => ctx.requestContext.plan === "enterprise" ? "gpt-4o" : "gpt-4o-mini"
+ * ```
+ */
+export type DynamicArgument<T> = T | (() => T) | (() => Promise<T>) | ((context: DynamicResolutionContext) => T) | ((context: DynamicResolutionContext) => Promise<T>);
+/**
+ * Dynamic options for generate() and stream() — pass functions
+ * instead of static values for context-aware resolution.
+ */
+export type DynamicOptions = {
+    model?: DynamicArgument<string>;
+    provider?: DynamicArgument<AIProviderName | string>;
+    temperature?: DynamicArgument<number>;
+    maxTokens?: DynamicArgument<number>;
+    systemPrompt?: DynamicArgument<string>;
+    /**
+     * Resolves to a `string[]` of tool names to enable.
+     * The resolved array is merged into `enabledToolNames` (and from there
+     * into `toolFilter`) — it does NOT replace `GenerateOptions.tools`,
+     * which is a `Record<string, Tool>` map of tool definitions.
+     */
+    tools?: DynamicArgument<string[]>;
+    timeout?: DynamicArgument<number>;
+    thinkingLevel?: DynamicArgument<"minimal" | "low" | "medium" | "high">;
+    disableTools?: DynamicArgument<boolean>;
+    enableAnalytics?: DynamicArgument<boolean>;
+    enableEvaluation?: DynamicArgument<boolean>;
+    input: {
+        text: string;
+        images?: Array<Buffer | string>;
+        files?: Array<Buffer | string>;
+    };
+    /**
+     * Context passed to dynamic resolver functions — any shape you want.
+     *
+     * This is intentionally separate from `GenerateOptions.context` (which is
+     * for telemetry/tracing metadata). If your resolvers need values from
+     * telemetry context (sessionId, userId, etc.), pass them here as well.
+     */
+    dynamicContext?: Record<string, unknown>;
+};
+export type ResolutionOptions = {
+    timeout?: number;
+    cache?: boolean;
+    cacheKey?: string;
+    cacheTtl?: number;
+    defaultValue?: unknown;
+    throwOnError?: boolean;
+};
+export type ResolutionResult<T> = {
+    value: T;
+    fromCache: boolean;
+    resolutionTime: number;
+    resolutionType: "static" | "sync-function" | "async-function" | "context-aware";
+};
+export type DynamicConfig<T> = {
+    [K in keyof T]: DynamicArgument<T[K]>;
+};
+export type ResolvedConfig<T> = {
+    [K in keyof T]: T[K] extends DynamicArgument<infer U> ? U : T[K];
+};
+export type DynamicCacheEntry<T> = {
+    value: T;
+    resolvedAt: number;
+    expiresAt: number;
+    key: string;
+};

package/dist/types/dynamic.js

@@ -0,0 +1,9 @@
+/**
+ * Dynamic Arguments Type Definitions
+ *
+ * Pass functions instead of static values to generate() and stream().
+ * Functions are resolved at runtime before provider dispatch.
+ *
+ * @module types/dynamic
+ */
+export {};

package/dist/types/file.d.ts

@@ -307,6 +307,16 @@ export type FileDetectorOptions = {
     maxRetries?: number;
     /** Initial retry delay in milliseconds with exponential backoff (default: 1000) */
     retryDelay?: number;
+    /**
+     * Caller-provided MIME type hint (e.g. "text/plain", "application/json").
+     * Used when the filename has no extension and magic-byte detection cannot
+     * identify the content — the common Slack/Curator extension-less-buffer
+     * case. When set to a trustworthy mimetype (not "application/octet-stream"),
+     * it short-circuits the detection strategy loop with a high-confidence
+     * result so small files on the eager file-processing path still honor the
+     * hint (the lazy FileReferenceRegistry path has its own hint-handling).
+     */
+    mimetypeHint?: string;
 };
 /**
  * Google AI Studio Files API types

package/dist/types/fileReference.d.ts

@@ -96,6 +96,15 @@ export type FileRegistrationOptions = {
     filename?: string;
     /** Override file type detection */
     fileType?: FileType;
+    /**
+     * Caller-provided MIME type hint (e.g. "text/plain", "application/json").
+     * Used when the filename has no extension and magic-byte detection cannot
+     * identify the content (common for Slack/Curator-style buffers where the
+     * original extension was stripped). Honored during type detection, mimeType
+     * assignment, and filename-extension synthesis. An explicit `fileType`
+     * override still wins over this hint.
+     */
+    mimetype?: string;
     /** Maximum preview length in characters */
     maxPreviewChars?: number;
     /** Skip persisting buffer to temp directory */

package/dist/types/generate.d.ts

@@ -230,6 +230,20 @@ export type GenerateOptions = {
      */
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;
+    /**
+     * Filter available tools by name.
+     * Only tools with names in this array will be made available.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     *
+     * @example
+     * ```typescript
+     * await neurolink.generate({
+     *   input: { text: "Search for information" },
+     *   enabledToolNames: ["websearchGrounding", "readFile"]
+     * });
+     * ```
+     */
+    enabledToolNames?: string[];
     timeout?: number | string;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
@@ -738,6 +752,21 @@ export type TextGenerationOptions = {
         director?: DirectorModeOptions;
     };
     tools?: Record<string, Tool>;
+    /**
+     * Filter available tools by name.
+     * Only tools with names in this array will be made available.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     * Merged into `toolFilter` before tool filtering runs.
+     *
+     * @example
+     * ```typescript
+     * await neurolink.generate({
+     *   input: { text: "Search for information" },
+     *   enabledToolNames: ["websearchGrounding", "readFile"]
+     * });
+     * ```
+     */
+    enabledToolNames?: string[];
     timeout?: number | string;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;

package/dist/types/index.d.ts

@@ -56,3 +56,4 @@ export * from "./exporter.js";
 export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
+export * from "./dynamic.js";

package/dist/types/index.js

@@ -58,3 +58,5 @@ export * from "./exporter.js";
 export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
+// Dynamic Arguments types
+export * from "./dynamic.js";

package/dist/types/scorer.d.ts

@@ -1,6 +1,6 @@
 /**
  * @file Scorer type definitions for NeuroLink evaluation system
- * Mastra-style modular scorer interfaces and types
+ * Modular scorer interfaces and types
  */
 import type { JsonObject } from "./common.js";
 import type { EnhancedEvaluationContext } from "./evaluation.js";

package/dist/types/scorer.js

@@ -1,5 +1,5 @@
 /**
  * @file Scorer type definitions for NeuroLink evaluation system
- * Mastra-style modular scorer interfaces and types
+ * Modular scorer interfaces and types
  */
 export {};

package/dist/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/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/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/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/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/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/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/utils/mimeTypeHints.js

@@ -0,0 +1,121 @@
+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] || "";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.56.1",
+  "version": "9.57.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {