@juspay/neurolink 9.56.2 → 9.57.1

package/dist/lib/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/lib/types/dynamic.js

@@ -0,0 +1,10 @@
+/**
+ * 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 {};
+//# sourceMappingURL=dynamic.js.map

package/dist/lib/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/lib/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/lib/types/index.js

@@ -58,4 +58,6 @@ export * from "./exporter.js";
 export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
+// Dynamic Arguments types
+export * from "./dynamic.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/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/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/conversationMemory.d.ts

@@ -5,6 +5,16 @@
 import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
 import type { ChatMessage, ConversationMemoryConfig, SessionMemory, TextGenerationOptions, TextGenerationResult } from "../types/index.js";
+/**
+ * Legacy sentinel string formerly written by the abort branch of
+ * handleGenerateTextInternalFailure (Curator SI-069 / SI-071). The producer is
+ * removed in this fix, but historical Redis sessions may still contain entries
+ * with this content. Filtered at the prompt-builder boundary so they never
+ * reach the provider — sessions self-heal on the next read without any
+ * migration. Keep in sync with any future renames; do not remove without a
+ * cross-repo grep.
+ */
+export declare const ABORT_LEGACY_SENTINEL = "[generation was interrupted]";
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values

package/dist/lib/utils/conversationMemory.js

@@ -10,6 +10,85 @@ import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { buildSummarizationPrompt } from "../context/prompts/summarizationPrompt.js";
 import { logger } from "./logger.js";
 const memoryTracer = tracers.memory;
+/**
+ * Legacy sentinel string formerly written by the abort branch of
+ * handleGenerateTextInternalFailure (Curator SI-069 / SI-071). The producer is
+ * removed in this fix, but historical Redis sessions may still contain entries
+ * with this content. Filtered at the prompt-builder boundary so they never
+ * reach the provider — sessions self-heal on the next read without any
+ * migration. Keep in sync with any future renames; do not remove without a
+ * cross-repo grep.
+ */
+export const ABORT_LEGACY_SENTINEL = "[generation was interrupted]";
+/**
+ * Tracks session IDs that have already emitted the
+ * "Dropped polluted assistant turns" warn log so we log once per session
+ * (not on every retrieval). The span attribute
+ * `neurolink.memory.polluted_turns_dropped` is still set every call, so
+ * Langfuse traces show the cleanup happening continuously even after the
+ * log is suppressed. Bounded to avoid unbounded growth on busy services —
+ * when capacity is reached the set is cleared (cheap) and warning resumes
+ * as if those sessions are new, which is acceptable behaviour.
+ */
+const POLLUTED_WARN_DEDUP_MAX = 1024;
+const pollutedWarnedSessions = new Set();
+/**
+ * True if a stored assistant turn looks like it was carrying tool activity
+ * (and is therefore safe to keep even with empty text content). storeTurn
+ * paths historically populate one of several fields depending on which
+ * provider/codepath wrote it, so this checks all of them. Mirrored across
+ * read filter + storage guard for symmetry.
+ *
+ *   - `msg.events` — stream-path event sequence (`tool:start`, `tool:end`)
+ *   - `msg.tool` / `msg.args` — assistant turn that invoked a tool by name
+ *   - `msg.result` — tool result attached to the assistant turn
+ *
+ * If none of these are set, the assistant turn is text-only.
+ *
+ * Named with the `message` prefix to avoid shadowing the local
+ * `hasToolActivity` boolean inside `storeConversationTurn` below — the two
+ * answer different questions (one inspects a stored message, the other
+ * inspects a live result object).
+ */
+function messageHasToolActivity(msg) {
+    if (msg.tool || msg.args || msg.result) {
+        return true;
+    }
+    const events = msg.events;
+    if (!Array.isArray(events)) {
+        return false;
+    }
+    return events.some((e) => {
+        const type = e?.type;
+        return type === "tool:start" || type === "tool:end";
+    });
+}
+/**
+ * Decides whether an assistant turn loaded from conversation memory is safe to
+ * include in the prompt sent to the provider. Drops:
+ *   - empty / whitespace-only text content with no tool activity
+ *   - the legacy abort sentinel — but only when the turn carries no tool
+ *     activity, mirroring the storeConversationTurn upper-layer guard so a
+ *     hypothetical tool-call-then-aborted turn doesn't lose its tool half
+ * tool_call and tool_result role messages are always preserved — they
+ * legitimately carry empty `content` (see redisConversationMemoryManager.ts:1870
+ * "Can be empty for tool calls"). Filtering them would break tool-pair
+ * semantics that downstream `repairToolPairs` relies on.
+ */
+function isPollutedAssistantTurn(msg) {
+    if (msg.role !== "assistant") {
+        return false;
+    }
+    const content = typeof msg.content === "string" ? msg.content : "";
+    const trimmed = content.trim();
+    if (trimmed === ABORT_LEGACY_SENTINEL) {
+        return !messageHasToolActivity(msg);
+    }
+    if (trimmed === "") {
+        return !messageHasToolActivity(msg);
+    }
+    return false;
+}
 // Cached NeuroLink instance for summarization to avoid creating a new instance per call
 let cachedSummarizer = null;
 /**
@@ -66,12 +145,49 @@ export async function getConversationMessages(conversationMemory, options) {
                 span.setAttribute("user.id", userId);
             }
             const enableSummarization = options.enableSummarization ?? undefined;
-            const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
+            const rawMessages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
+            // Read-time filter: drop assistant turns that are empty/whitespace or
+            // carry the legacy abort sentinel before they reach the provider.
+            // Self-heals historical Redis sessions polluted by the now-removed
+            // abort-path memory write (Curator SI-069 / SI-071) and defends
+            // against any future "fabricate-on-error" regression. Telemetry
+            // attributes record how many turns were dropped so polluted sessions
+            // are visible in Langfuse traces.
+            const messages = rawMessages.filter((msg) => !isPollutedAssistantTurn(msg));
+            const droppedCount = rawMessages.length - messages.length;
+            if (droppedCount > 0) {
+                // Span attribute is always set so polluted sessions stay visible in
+                // Langfuse traces on every read — that's the persistent debugging
+                // signal. The warn log is deduped per session so a long-lived
+                // polluted conversation only generates one log line, not one per
+                // turn (would otherwise be noisy at scale).
+                span.setAttribute("neurolink.memory.polluted_turns_dropped", droppedCount);
+                const alreadyWarned = pollutedWarnedSessions.has(sessionId);
+                if (!alreadyWarned) {
+                    if (pollutedWarnedSessions.size >= POLLUTED_WARN_DEDUP_MAX) {
+                        pollutedWarnedSessions.clear();
+                    }
+                    pollutedWarnedSessions.add(sessionId);
+                    logger.warn("[conversationMemoryUtils] Dropped polluted assistant turns from prompt context (logged once per session — span attribute records every read)", {
+                        sessionId,
+                        droppedCount,
+                        remainingCount: messages.length,
+                    });
+                }
+                else {
+                    logger.debug("[conversationMemoryUtils] Dropped polluted assistant turns (warn already logged for this session)", {
+                        sessionId,
+                        droppedCount,
+                        remainingCount: messages.length,
+                    });
+                }
+            }
             span.setAttribute("message.count", messages.length);
             if (logger.shouldLog("debug")) {
                 logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
                     sessionId,
                     messageCount: messages.length,
+                    droppedPollutedCount: droppedCount,
                     messageTypes: messages.map((m) => m.role),
                 });
             }
@@ -147,6 +263,19 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
         });
         return;
     }
+    // Belt-and-braces guard against the abort sentinel (Curator SI-069 / SI-071).
+    // The abort path itself was fixed in handleGenerateTextInternalFailure to
+    // never call this function, but we reject the legacy sentinel here too so a
+    // future regression cannot re-introduce the same pollution. Tool-bearing
+    // turns are explicitly preserved (the model may call a tool then abort).
+    if (aiResponse.trim() === ABORT_LEGACY_SENTINEL && !hasToolActivity) {
+        logger.warn("[conversationMemoryUtils] Refusing to store legacy abort sentinel — see Curator SI-069 / SI-071", {
+            sessionId,
+            userId,
+            userMessageLength: userMessage.length,
+        });
+        return;
+    }
     let providerDetails;
     if (result.provider && result.model) {
         providerDetails = {
@@ -154,6 +283,60 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
             model: result.model,
         };
     }
+    // Persist a minimal `events` marker only on tool-bearing assistant turns
+    // whose surface text would otherwise trigger the read-time filter (empty /
+    // whitespace-only content). Turns that already have substantive text are
+    // never dropped by isPollutedAssistantTurn, so attaching synthesised events
+    // to them would change the stored shape and token estimation for no
+    // benefit. Sentinel-content turns never reach this point — the upper-layer
+    // guard at line 340 short-circuits them.
+    let toolActivityEvents;
+    if (hasToolActivity && !aiResponse.trim()) {
+        const now = Date.now();
+        const usedNames = new Set();
+        if (Array.isArray(result.toolsUsed)) {
+            for (const t of result.toolsUsed) {
+                if (typeof t === "string" && t) {
+                    usedNames.add(t);
+                }
+            }
+        }
+        if (Array.isArray(result.toolExecutions)) {
+            for (const exec of result.toolExecutions) {
+                const name = exec?.toolName;
+                if (typeof name === "string" && name) {
+                    usedNames.add(name);
+                }
+            }
+        }
+        toolActivityEvents = [];
+        let seq = 0;
+        for (const name of usedNames) {
+            // Match the canonical ToolExecutionEvent shape (src/lib/types/tools.ts):
+            // `tool` is the required field, `toolName` is the documented compat
+            // alias. Populate both so downstream consumers reading either name
+            // work uniformly.
+            toolActivityEvents.push({
+                type: "tool:start",
+                seq: seq++,
+                timestamp: now,
+                tool: name,
+                toolName: name,
+            });
+        }
+        if (toolActivityEvents.length === 0) {
+            // Tool activity reported but no names extractable — still leave a
+            // marker so retrieval doesn't drop the turn. Both `tool` and
+            // `toolName` are populated for the same compat reason.
+            toolActivityEvents.push({
+                type: "tool:start",
+                seq: 0,
+                timestamp: now,
+                tool: "unknown",
+                toolName: "unknown",
+            });
+        }
+    }
     await memoryTracer.startActiveSpan("neurolink.conversation.storeTurn", {
         kind: SpanKind.INTERNAL,
         attributes: {
@@ -174,6 +357,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                 providerDetails,
                 enableSummarization: originalOptions.enableSummarization,
                 requestId,
+                events: toolActivityEvents,
                 tokenUsage: result.usage
                     ? {
                         inputTokens: result.usage.input,

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

@@ -17,6 +17,7 @@ export declare const ERROR_CODES: {
     readonly PROVIDER_NOT_AVAILABLE: "PROVIDER_NOT_AVAILABLE";
     readonly PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED";
     readonly PROVIDER_QUOTA_EXCEEDED: "PROVIDER_QUOTA_EXCEEDED";
+    readonly OPERATION_ABORTED: "OPERATION_ABORTED";
     readonly INVALID_CONFIGURATION: "INVALID_CONFIGURATION";
     readonly MISSING_CONFIGURATION: "MISSING_CONFIGURATION";
     readonly INVALID_VIDEO_RESOLUTION: "INVALID_VIDEO_RESOLUTION";
@@ -106,6 +107,18 @@ export declare class ErrorFactory {
      * Create a memory exhaustion error
      */
     static memoryExhausted(toolName: string, memoryUsageMB: number): NeuroLinkError;
+    /**
+     * Create a typed abort error preserving the originating exception. Callers
+     * can switch on `error.category === ErrorCategory.ABORT` and
+     * `error.code === ERROR_CODES.OPERATION_ABORTED` instead of message-string
+     * matching DOMException / AI SDK error wrappers.
+     *
+     * `error.name` is intentionally set to "AbortError" (overriding the default
+     * "NeuroLinkError") so existing callers that branch on
+     * `err.name === "AbortError"` keep working without code changes — the new
+     * structured fields (category, code, retriable) are additive.
+     */
+    static aborted(originalError?: Error): NeuroLinkError;
     /**
      * Create a missing configuration error (e.g., missing API key)
      */

package/dist/lib/utils/errorHandling.js

@@ -23,6 +23,8 @@ export const ERROR_CODES = {
     PROVIDER_NOT_AVAILABLE: "PROVIDER_NOT_AVAILABLE",
     PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
     PROVIDER_QUOTA_EXCEEDED: "PROVIDER_QUOTA_EXCEEDED",
+    // Cancellation
+    OPERATION_ABORTED: "OPERATION_ABORTED",
     // Configuration errors
     INVALID_CONFIGURATION: "INVALID_CONFIGURATION",
     MISSING_CONFIGURATION: "MISSING_CONFIGURATION",
@@ -201,6 +203,30 @@ export class ErrorFactory {
             toolName,
         });
     }
+    /**
+     * Create a typed abort error preserving the originating exception. Callers
+     * can switch on `error.category === ErrorCategory.ABORT` and
+     * `error.code === ERROR_CODES.OPERATION_ABORTED` instead of message-string
+     * matching DOMException / AI SDK error wrappers.
+     *
+     * `error.name` is intentionally set to "AbortError" (overriding the default
+     * "NeuroLinkError") so existing callers that branch on
+     * `err.name === "AbortError"` keep working without code changes — the new
+     * structured fields (category, code, retriable) are additive.
+     */
+    static aborted(originalError) {
+        const err = new NeuroLinkError({
+            code: ERROR_CODES.OPERATION_ABORTED,
+            message: originalError?.message || "The operation was aborted",
+            category: ErrorCategory.ABORT,
+            severity: ErrorSeverity.LOW,
+            retriable: false,
+            context: {},
+            originalError,
+        });
+        err.name = "AbortError";
+        return err;
+    }
     // ============================================================================
     // CONFIGURATION ERRORS
     // ============================================================================
@@ -904,6 +930,11 @@ export function isAbortError(error) {
     if (error instanceof Error && error.name === "AbortError") {
         return true;
     }
+    // Typed NeuroLinkError abort - canonical from-now-on shape.
+    if (error instanceof NeuroLinkError &&
+        error.category === ErrorCategory.ABORT) {
+        return true;
+    }
     if (error instanceof Error &&
         (error.message?.includes("This operation was aborted") ||
             error.message?.includes("The operation was aborted") ||

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;
@@ -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;