@juspay/neurolink 9.57.0 → 9.57.1

package/dist/constants/enums.d.ts

@@ -594,7 +594,14 @@ export declare enum ErrorCategory {
     PERMISSION = "permission",
     CONFIGURATION = "configuration",
     EXECUTION = "execution",
-    SYSTEM = "system"
+    SYSTEM = "system",
+    /**
+     * Caller-initiated cancellation via AbortSignal. Distinct from system errors
+     * — represents a user/control-plane decision, not a SDK or provider failure.
+     * Consumers can branch on this category to differentiate "user cancelled"
+     * from "server error" without resorting to message-string matching.
+     */
+    ABORT = "abort"
 }
 export declare enum ErrorSeverity {
     LOW = "low",

package/dist/constants/enums.js

@@ -812,6 +812,13 @@ export var ErrorCategory;
     ErrorCategory["CONFIGURATION"] = "configuration";
     ErrorCategory["EXECUTION"] = "execution";
     ErrorCategory["SYSTEM"] = "system";
+    /**
+     * Caller-initiated cancellation via AbortSignal. Distinct from system errors
+     * — represents a user/control-plane decision, not a SDK or provider failure.
+     * Consumers can branch on this category to differentiate "user cancelled"
+     * from "server error" without resorting to message-string matching.
+     */
+    ErrorCategory["ABORT"] = "abort";
 })(ErrorCategory || (ErrorCategory = {}));
 // Error severity levels
 export var ErrorSeverity;

package/dist/lib/constants/enums.d.ts

@@ -594,7 +594,14 @@ export declare enum ErrorCategory {
     PERMISSION = "permission",
     CONFIGURATION = "configuration",
     EXECUTION = "execution",
-    SYSTEM = "system"
+    SYSTEM = "system",
+    /**
+     * Caller-initiated cancellation via AbortSignal. Distinct from system errors
+     * — represents a user/control-plane decision, not a SDK or provider failure.
+     * Consumers can branch on this category to differentiate "user cancelled"
+     * from "server error" without resorting to message-string matching.
+     */
+    ABORT = "abort"
 }
 export declare enum ErrorSeverity {
     LOW = "low",

package/dist/lib/constants/enums.js

@@ -812,6 +812,13 @@ export var ErrorCategory;
     ErrorCategory["CONFIGURATION"] = "configuration";
     ErrorCategory["EXECUTION"] = "execution";
     ErrorCategory["SYSTEM"] = "system";
+    /**
+     * Caller-initiated cancellation via AbortSignal. Distinct from system errors
+     * — represents a user/control-plane decision, not a SDK or provider failure.
+     * Consumers can branch on this category to differentiate "user cancelled"
+     * from "server error" without resorting to message-string matching.
+     */
+    ErrorCategory["ABORT"] = "abort";
 })(ErrorCategory || (ErrorCategory = {}));
 // Error severity levels
 export var ErrorSeverity;

package/dist/lib/neurolink.d.ts

@@ -881,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

package/dist/lib/neurolink.js

@@ -2324,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 ??
@@ -2674,10 +2689,22 @@ 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");
@@ -2972,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,
@@ -2979,6 +3011,7 @@ Current user's request: ${currentInput}`;
                 responseTime: 0,
                 error: error instanceof Error ? error.message : String(error),
                 success: false,
+                aborted,
             });
         }
         catch (emitError) {
@@ -3326,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 {
@@ -3385,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;
         }
     }
@@ -3442,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`, {
@@ -3471,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) {
@@ -5701,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
@@ -6643,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: {
@@ -6806,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();

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/neurolink.d.ts

@@ -881,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