@juspay/neurolink 13.5.0 → 13.6.0

package/dist/core/nativeGenerateLoop.js

@@ -17,6 +17,7 @@ import { observeGeneration } from "../telemetry/observation.js";
 import { StepSpans, withGeneration } from "../telemetry/withSpan.js";
 import { logger } from "../utils/logger.js";
 import { guardToolExecutor } from "./toolExecutionGuards.js";
+import { resolveLiveTool } from "../tools/toolDiscovery.js";
 const DEFAULT_TOOL_CHOICE_STEPS = 1;
 /**
  * A choice that compels a tool call: `"required"` or a named tool, in either
@@ -74,9 +75,9 @@ const warnUndeclaredForcedTool = (toolName, step, source) => {
 };
 /**
  * The names this request actually carries, in the record shape
- * `declaredTools` takes. The loop sends `args.tools`, built once by the
- * caller; `args.toolsRecord` can hold more (discovery hydrates into it, and
- * this loop never re-declares), so only `tools` answers "is it offered".
+ * `declaredTools` takes. `args.toolsRecord` can hold more than is declared
+ * (discovery hydrates into it), so only the sent declarations answer "is it
+ * offered".
  * Null prototype: a tool may be named `__proto__` or `constructor`.
  */
 const declaredToolRecord = (tools) => {
@@ -336,6 +337,8 @@ const parseToolInput = (raw) => {
         return { input: {}, error: "arguments were not valid JSON" };
     }
 };
+/** A tool's inputSchema with its lazy (function) form, if any, resolved. */
+export const resolveToolInputSchema = (schema) => typeof schema === "function" ? resolveToolInputSchema(schema()) : schema;
 /**
  * Validate parsed input against the tool's own schema when it exposes one.
  *
@@ -346,8 +349,12 @@ const parseToolInput = (raw) => {
  * validator this loop has no business carrying.
  */
 const validateToolInput = (tool, input) => {
-    const schema = tool?.inputSchema;
-    if (typeof schema?.safeParse !== "function") {
+    const schema = tool?.inputSchema
+        ? resolveToolInputSchema(tool.inputSchema)
+        : undefined;
+    if (!schema ||
+        !("safeParse" in schema) ||
+        typeof schema.safeParse !== "function") {
         return undefined;
     }
     const result = schema.safeParse(input);
@@ -447,7 +454,7 @@ function generateObservedStep(args, request) {
     });
 }
 export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
-    const stepSpans = new StepSpans();
+    const stepSpans = new StepSpans("generate");
     try {
         return await runGenerateSteps(args, toolExecutionSummaries, stepSpans);
     }
@@ -478,11 +485,28 @@ async function runGenerateSteps(args, toolExecutionSummaries, stepSpans) {
     // answer is that result — not a thrown turn.
     let preReask;
     const hasTools = Boolean(args.tools && args.tools.length > 0);
+    // The declarations actually sent. Starts as the caller's list and grows when
+    // a tool joins toolsRecord mid-turn (discovery loads tools into it).
+    const liveTools = args.tools ? [...args.tools] : undefined;
+    const declaredNames = declaredToolRecord(args.tools);
     // Completed-step records for `prepareStep`; one per step that returned.
     const stepRecords = [];
     for (let step = 0; step < args.maxSteps; step++) {
         steps = step + 1;
         stepSpans.begin(steps);
+        if (liveTools && args.declareTool) {
+            const loaded = [];
+            for (const name of Object.keys(args.toolsRecord)) {
+                if (!declaredNames[name]) {
+                    liveTools.push(args.declareTool(name, args.toolsRecord[name]));
+                    declaredNames[name] = true;
+                    loaded.push(name);
+                }
+            }
+            if (loaded.length > 0) {
+                logger.debug(`[nativeGenerateLoop] ${loaded.length} tool(s) hydrated mid-turn via discovery: ${loaded.join(", ")}`);
+            }
+        }
         // The forced-choice window and the caller's hook are resolved BEFORE the
         // re-ask override below: the re-ask has to win, since its whole point is
         // a request with tools disabled.
@@ -498,7 +522,7 @@ async function runGenerateSteps(args, toolExecutionSummaries, stepSpans) {
                 steps: stepRecords,
                 maxSteps: args.maxSteps,
                 model: args.modelId,
-                declaredTools: declaredToolRecord(args.tools),
+                declaredTools: declaredToolRecord(liveTools),
                 ...(args.abortSignal ? { abortSignal: args.abortSignal } : {}),
             })
             : undefined;
@@ -519,7 +543,7 @@ async function runGenerateSteps(args, toolExecutionSummaries, stepSpans) {
         }
         const runThisStep = () => generateObservedStep(args, {
             prompt: args.conversation,
-            ...(args.tools && args.tools.length > 0 ? { tools: args.tools } : {}),
+            ...(liveTools && liveTools.length > 0 ? { tools: liveTools } : {}),
             // The v3 call option is an OBJECT — `{ type: "none" }`. Passing the
             // bare string "none" type-checks against `unknown` and is then
             // dropped by every converter that switches on `choice.type`, so the
@@ -688,7 +712,9 @@ async function runGenerateSteps(args, toolExecutionSummaries, stepSpans) {
             const startTime = new Date();
             const parsed = parseToolInput(call.input);
             const input = parsed.input;
-            const tool = args.toolsRecord[name];
+            // resolveLiveTool also loads a deferred tool the model called by its
+            // catalog name without searching first.
+            const tool = resolveLiveTool(args.toolsRecord, name);
             let output;
             let failure;
             const rejection = parsed.error ??

package/dist/evaluation/index.d.ts

@@ -1,3 +1,4 @@
+import "../services/server/ai/observability/instrumentation.js";
 import type { EvaluationData, GenerateResult, AutoEvaluationConfig, EvaluationConfig } from "../types/index.js";
 import type { LanguageModelV3CallOptions } from "../types/index.js";
 export * from "./errors/index.js";

package/dist/evaluation/index.js

@@ -1,3 +1,7 @@
+// Imported on its own, this entry starts tracing at its first span, as the
+// main entry does. The import sits here rather than in the shared tracers so
+// that the client entry stays free of the OpenTelemetry Node SDK.
+import "../services/server/ai/observability/instrumentation.js";
 import { ContextBuilder } from "./contextBuilder.js";
 import { RAGASEvaluator } from "./ragasEvaluator.js";
 import { mapToEvaluationData } from "./scoring.js";

package/dist/evaluation/ragasEvaluator.js

@@ -38,6 +38,7 @@ export class RAGASEvaluator {
         return withSpan({
             name: "neurolink.evaluation.ragas",
             tracer: tracers.sdk,
+            observationType: "span",
             attributes: {
                 "evaluation.provider": this.providerName,
                 "evaluation.model": this.evaluationModel,

package/dist/mcp/externalServerManager.js

@@ -14,6 +14,7 @@ import { toolRegistry } from "./toolRegistry.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
 import { detectCategory } from "../utils/mcpDefaults.js";
 import { isObject, isNonNullObject } from "../utils/typeUtils.js";
+import { recordMCPToolCall } from "../telemetry/aiMetrics.js";
 import { tracers } from "../telemetry/tracers.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 // `@modelcontextprotocol/sdk`'s stdio transport (imported above) does
@@ -2045,8 +2046,9 @@ export class ExternalServerManager extends EventEmitter {
             if (result.success) {
                 // A resolved `{ isError: true }` still comes back with success:true so
                 // the caller receives the MCP error payload as-is, but it is a failed
-                // call for telemetry: label mcp_tool_calls_total accordingly instead
-                // of counting every resolved error as a success.
+                // call for telemetry: count it in the server's totalErrors and as
+                // success=false in mcp_tool_calls_total instead of counting every
+                // resolved error as a success.
                 const resolvedError = result.isErrorResult === true;
                 if (resolvedError) {
                     instance.metrics.totalErrors++;
@@ -2056,6 +2058,7 @@ export class ExternalServerManager extends EventEmitter {
                     : `[ExternalServerManager] Tool executed successfully: ${toolName} on ${serverId}`, {
                     duration,
                 });
+                recordMCPToolCall(toolName, duration, !resolvedError);
                 return result.data;
             }
             else {
@@ -2064,6 +2067,7 @@ export class ExternalServerManager extends EventEmitter {
         }
         catch (error) {
             instance.metrics.totalErrors++;
+            recordMCPToolCall(toolName, Date.now() - startTime, false);
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
             // The SDK rejects with its connection-closed error when the server is
             // gone. Without this transition the instance stayed "connected" and

package/dist/mcp/toolRegistry.js

@@ -293,6 +293,9 @@ export class MCPToolRegistry extends MCPRegistry {
             attributes: {
                 "tool.name": toolName,
                 [ATTR.MCP_SERVER_ID]: preResolvedServerId || "builtin",
+                // Registry-level wrapper around the `tool` observation of the same
+                // call: it stays an OpenTelemetry span but is not exported.
+                [ATTR.NL_INTERNAL]: true,
             },
         }, async (span) => {
             try {

package/dist/neurolink.d.ts

@@ -1,5 +1,5 @@
 import type { DecisionCallerOptions, DecisionLimitsQuery, DecisionLimitsReading, DecisionOptions, DecisionResult, AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
-import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ConversationSeedMessage, ConversationSeedOptions, RecordConversationTurnOptions, RecordConversationTurnResult, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ExporterStatus, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ConversationSeedMessage, ConversationSeedOptions, RecordConversationTurnOptions, RecordConversationTurnResult, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
@@ -687,6 +687,10 @@ export declare class NeuroLink {
     isTelemetryEnabled(): boolean;
     /**
      * Get comprehensive telemetry status including Langfuse and OpenTelemetry state
+     * and every registered exporter with its queued, delivered and dropped spans.
+     * `openTelemetry.enabled` is whether tracing is initialized, as it always
+     * was. Beside a host TracerProvider, `openTelemetry.usingExternalProvider`
+     * is `true`: NeuroLink exports nothing to the endpoint.
      */
     getTelemetryStatus(): {
         enabled: boolean;
@@ -699,7 +703,9 @@ export declare class NeuroLink {
             enabled: boolean;
             endpoint?: string;
             serviceName?: string;
+            usingExternalProvider?: boolean;
         };
+        exporters: ExporterStatus[];
     };
     /**
      * Get aggregated observability metrics (latency, tokens, cost, success rate)
@@ -2714,13 +2720,15 @@ export declare class NeuroLink {
      * on the wire can differ from the instance's.
      *
      * Fail-open by construction, in three layers. Without a decision provider
-     * nothing runs at all — no hook, no event — and the consumer gets the null
-     * it always got. Everything a host can reach (its hook's return value, the
-     * event payloads, the answer split, `onAnswers`) runs inside one `try`;
-     * whatever a host throws, the consumer gets what `tryRunDecide` alone
-     * would have given it. And every host-facing value is a `structuredClone`,
-     * so a hook or listener that edits what it is handed edits neither the
-     * wire request nor the consumer's own question objects.
+     * no hook runs and no event is emitted: the call goes to `tryRunDecide`
+     * alone, which records the WARNING `decide` observation it always did, and
+     * the consumer gets the null it always got. Everything a host can reach
+     * (its hook's return value, the event payloads, the answer split,
+     * `onAnswers`) runs inside one `try`; whatever a host throws, the consumer
+     * gets what `tryRunDecide` alone would have given it. And every
+     * host-facing value is a `structuredClone`, so a hook or listener that
+     * edits what it is handed edits neither the wire request nor the
+     * consumer's own question objects.
      *
      * `outer` is what the surrounding `generate()` / `stream()` supplies —
      * per-call credentials, abort signal, ids — and wins over the same fields

package/dist/neurolink.js

@@ -71,8 +71,9 @@ import { getMetricsAggregator, MetricsAggregator, } from "./observability/metric
 import { AnalyticsService, calculateAdvancedCost, parseAnalyticsQualityScore, } from "./analytics/index.js";
 import { SpanStatus, SpanType, CircuitBreakerOpenError, ConversationMemoryError, DEFAULT_DECISION_HOOK_TIMEOUT_MS, MAX_DECISION_HOOK_TIMEOUT_MS, ModelAccessDeniedError, } from "./types/index.js";
 import { resolveTerminalAgentMode } from "./agent/prompts/terminalAgentPrompt.js";
+import { getExporterRegistry } from "./observability/exporterRegistry.js";
 import { SpanSerializer } from "./observability/utils/spanSerializer.js";
-import { withSpan } from "./telemetry/withSpan.js";
+import { endSpanWhenDropped, withSpan } from "./telemetry/withSpan.js";
 import { getActiveTraceContext } from "./telemetry/traceContext.js";
 import { calculateCost } from "./utils/pricing.js";
 import { acquireTelemetry, ensureTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, isOpenTelemetryInitialized, releaseTelemetry, setLangfuseContext, traceMetadataFromContext, } from "./services/server/ai/observability/instrumentation.js";
@@ -410,6 +411,9 @@ function observeTurn(span, attrs) {
     }
 }
 function startTurn(span, optionsOrPrompt) {
+    if (!span.isRecording()) {
+        return;
+    }
     observeTurn(span, { input: turnInput(optionsOrPrompt) });
     if (typeof optionsOrPrompt !== "string") {
         const name = optionsOrPrompt.context?.observationName;
@@ -474,65 +478,87 @@ function traceTurnStream(result, span, turnContext) {
                 : "stream closed before first chunk");
         }
     };
+    const advance = async (pull, afterThrow = false) => {
+        started = true;
+        try {
+            const step = await context.with(turnContext, pull);
+            if (step.done) {
+                span.setStatus({ code: SpanStatusCode.OK });
+                end(observationLevel(result.finishReason));
+                return { done: true, value: undefined };
+            }
+            const content = typeof step.value === "object" && step.value !== null
+                ? step.value.content
+                : undefined;
+            if (typeof content === "string") {
+                output += content;
+            }
+            return step;
+        }
+        catch (error) {
+            failTurnSpan(span, error instanceof Error ? error : new Error(String(error)));
+            // A consumer that throws into the stream ends it early, as return()
+            // does, and the root has always kept the model in that case.
+            if (afterThrow) {
+                observeTurn(span, { metadata: { model: result.model } });
+            }
+            finish();
+            throw error;
+        }
+    };
     const traced = {
         async next() {
             if (ended) {
                 return { done: true, value: undefined };
             }
-            started = true;
-            try {
-                const step = await context.with(turnContext, () => iterator.next());
-                if (step.done) {
-                    span.setStatus({ code: SpanStatusCode.OK });
-                    end(observationLevel(result.finishReason));
-                    return { done: true, value: undefined };
-                }
-                const content = typeof step.value === "object" && step.value !== null
-                    ? step.value.content
-                    : undefined;
-                if (typeof content === "string") {
-                    output += content;
-                }
-                return step;
-            }
-            catch (error) {
-                failTurnSpan(span, error instanceof Error ? error : new Error(String(error)));
-                finish();
-                throw error;
-            }
+            return advance(() => iterator.next());
         },
         async return() {
             await close();
             return { done: true, value: undefined };
         },
         async throw(error) {
-            await close();
-            throw error;
+            const forward = iterator.throw;
+            if (ended || forward === undefined) {
+                await close();
+                throw error;
+            }
+            return advance(() => forward.call(iterator, error), true);
         },
         [Symbol.asyncIterator]() {
             return traced;
         },
     };
+    endSpanWhenDropped(traced, span);
     return traced;
 }
+/**
+ * Runs every pull of `stream` inside `drainContext`, and forwards `return()`
+ * and `throw()` to it even before the first `next()`. A generator that has not
+ * started never enters its body, so wrapping the drain in one would swallow a
+ * pre-start close and leave the drain's own settle step unreached.
+ */
 function drainInContext(stream, drainContext) {
-    return (async function* () {
-        const iterator = stream[Symbol.asyncIterator]();
-        try {
-            while (true) {
-                const step = await context.with(drainContext, () => iterator.next());
-                if (step.done) {
-                    return;
-                }
-                yield step.value;
+    const iterator = stream[Symbol.asyncIterator]();
+    const drained = {
+        next: () => context.with(drainContext, () => iterator.next()),
+        async return() {
+            await context.with(drainContext, async () => iterator.return?.());
+            return { done: true, value: undefined };
+        },
+        async throw(error) {
+            const forward = iterator.throw;
+            if (forward === undefined) {
+                await context.with(drainContext, async () => iterator.return?.());
+                throw error;
             }
-        }
-        finally {
-            await context.with(drainContext, async () => {
-                await iterator.return?.();
-            });
-        }
-    })();
+            return context.with(drainContext, () => forward.call(iterator, error));
+        },
+        [Symbol.asyncIterator]() {
+            return drained;
+        },
+    };
+    return drained;
 }
 /** Monotonic source for {@link NeuroLink.logInstanceId}. Process-local by design. */
 let neuroLinkInstanceCounter = 0;
@@ -834,8 +860,8 @@ export class NeuroLink {
         }, callback);
     }
     createMetricsTraceContext() {
-        // Attempt to reuse the active OTel trace context so Pipeline B spans
-        // land in the same Langfuse trace as Pipeline A spans.
+        // Reuse the active OTel trace context so the in-process span records
+        // carry the traceId of the exported OTEL trace of the same request.
         const activeSpan = trace.getSpan(context.active());
         if (activeSpan) {
             const spanCtx = activeSpan.spanContext();
@@ -3168,11 +3194,15 @@ Current user's request: ${currentInput}`;
     }
     /**
      * Get comprehensive telemetry status including Langfuse and OpenTelemetry state
+     * and every registered exporter with its queued, delivered and dropped spans.
+     * `openTelemetry.enabled` is whether tracing is initialized, as it always
+     * was. Beside a host TracerProvider, `openTelemetry.usingExternalProvider`
+     * is `true`: NeuroLink exports nothing to the endpoint.
      */
     getTelemetryStatus() {
         const langfuseConfig = this.observabilityConfig?.langfuse;
         const langfuseOptions = typeof langfuseConfig === "object" ? langfuseConfig : undefined;
-        const { hasProcessor } = getLangfuseHealthStatus();
+        const { hasProcessor, usingExternalProvider } = getLangfuseHealthStatus();
         return {
             enabled: isOpenTelemetryInitialized(),
             langfuse: langfuseConfig !== undefined || hasProcessor
@@ -3188,8 +3218,10 @@ Current user's request: ${currentInput}`;
                     enabled: isOpenTelemetryInitialized(),
                     endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
                     serviceName: process.env.OTEL_SERVICE_NAME,
+                    ...(usingExternalProvider && { usingExternalProvider }),
                 }
                 : undefined,
+            exporters: getExporterRegistry().getStatuses(),
         };
     }
     /**
@@ -7435,8 +7467,12 @@ Current user's request: ${currentInput}`;
                 return { done: true, value: undefined };
             },
             async throw(error) {
-                await scope.run(eventScope, async () => iterator.return?.());
-                throw error;
+                const forward = iterator.throw;
+                if (forward === undefined) {
+                    await scope.run(eventScope, async () => iterator.return?.());
+                    throw error;
+                }
+                return scope.run(eventScope, () => forward.call(iterator, error));
             },
             [Symbol.asyncIterator]() {
                 return bound;
@@ -7805,6 +7841,7 @@ Current user's request: ${currentInput}`;
                     },
                 });
                 attempt.stream = drainInContext(attempt.stream, context.active());
+                endSpanWhenDropped(attempt.stream, streamSpan);
                 return attempt;
             }));
             if (streamSttTranscription) {
@@ -8615,7 +8652,18 @@ Current user's request: ${currentInput}`;
                 }
                 return stream.return(value);
             },
-            throw: (error) => stream.throw(error),
+            throw: async (error) => {
+                if (!started) {
+                    started = true;
+                    await this.settleStandardStreamDrain(drain, {
+                        accumulatedContent: "",
+                        chunkCount: 0,
+                        streamError: error instanceof Error ? error : new Error(String(error)),
+                        resolvedUsage: undefined,
+                    });
+                }
+                return stream.throw(error);
+            },
             [Symbol.asyncIterator]: () => guarded,
         };
         return guarded;
@@ -14066,13 +14114,15 @@ Current user's request: ${currentInput}`;
      * on the wire can differ from the instance's.
      *
      * Fail-open by construction, in three layers. Without a decision provider
-     * nothing runs at all — no hook, no event — and the consumer gets the null
-     * it always got. Everything a host can reach (its hook's return value, the
-     * event payloads, the answer split, `onAnswers`) runs inside one `try`;
-     * whatever a host throws, the consumer gets what `tryRunDecide` alone
-     * would have given it. And every host-facing value is a `structuredClone`,
-     * so a hook or listener that edits what it is handed edits neither the
-     * wire request nor the consumer's own question objects.
+     * no hook runs and no event is emitted: the call goes to `tryRunDecide`
+     * alone, which records the WARNING `decide` observation it always did, and
+     * the consumer gets the null it always got. Everything a host can reach
+     * (its hook's return value, the event payloads, the answer split,
+     * `onAnswers`) runs inside one `try`; whatever a host throws, the consumer
+     * gets what `tryRunDecide` alone would have given it. And every
+     * host-facing value is a `structuredClone`, so a hook or listener that
+     * edits what it is handed edits neither the wire request nor the
+     * consumer's own question objects.
      *
      * `outer` is what the surrounding `generate()` / `stream()` supplies —
      * per-call credentials, abort signal, ids — and wins over the same fields
@@ -14094,9 +14144,10 @@ Current user's request: ${currentInput}`;
         if (!site) {
             return this.tryRunDecide(merged);
         }
-        // Inert without a decision provider: a host's hook must not sit on the
-        // request path of a tenant that has no decision model to reach, and an
-        // event for a call that could never be made would only mislead.
+        // No host hook or event without a decision provider: a hook must not sit
+        // on the request path of a tenant that has no decision model to reach, and
+        // an event for a call that could never be made would only mislead. The
+        // plain call still runs, so the WARNING observation it records is kept.
         if (!this.resolveDecisionProviderName(merged.provider, merged.credentials)) {
             return this.tryRunDecide(merged);
         }
@@ -14419,11 +14470,14 @@ Current user's request: ${currentInput}`;
                         ? { "decision.upstream_ms": result.upstreamMs }
                         : {}),
                 });
-                // BOTH aggregators, exactly as the generate path does. The
-                // instance one is what `neurolink.getMetrics()` / `getSpans()`
-                // read; the global one is what the exporters drain. Recording to
-                // only the global one would make a decision invisible to the very
-                // API a caller would use to check whether it ran.
+                // BOTH aggregators, exactly as the generate path does. They are
+                // in-process stores that are never exported: what Langfuse and the
+                // OTLP exporters receive for this decision is the `decide`
+                // generation span. The instance one is what
+                // `neurolink.getMetrics()` / `getSpans()` read; the global one is
+                // what `getMetricsAggregator()` readers see. Recording to only the
+                // global one would make a decision invisible to the very API a
+                // caller would use to check whether it ran.
                 const ended = SpanSerializer.endSpan(span, SpanStatus.OK);
                 this.metricsAggregator.recordSpan(ended);
                 getMetricsAggregator().recordSpan(ended);

package/dist/observability/FEATURE-STATUS.md

@@ -160,10 +160,6 @@ neurolink observability status
 neurolink observability metrics
 neurolink obs metrics --detailed
 
-# List exporters
-neurolink observability exporters
-neurolink obs exp --format json
-
 # Cost breakdown
 neurolink observability costs
 neurolink obs costs --by-model --by-provider

package/dist/observability/exporterRegistry.d.ts

@@ -3,7 +3,7 @@
  * Manages multiple observability exporters with circuit breaker protection
  */
 import type { BaseExporter } from "./exporters/baseExporter.js";
-import type { ExportResult, ExporterHealthStatus, ObservabilityCircuitBreakerConfig, ObservabilityCircuitBreakerState, Sampler, SpanData } from "../types/index.js";
+import type { ExportResult, ExporterHealthStatus, ExporterStatus, ObservabilityCircuitBreakerConfig, ObservabilityCircuitBreakerState, Sampler, SpanData } from "../types/index.js";
 /**
  * Registry for managing multiple observability exporters
  * Includes circuit breaker protection to prevent cascading failures
@@ -117,6 +117,11 @@ export declare class ExporterRegistry {
      * Get total pending spans across all exporters
      */
     getTotalPendingSpans(): number;
+    /**
+     * Snapshot of every registered exporter without a network call: whether it
+     * runs, what is queued, delivered and dropped, and an open circuit breaker
+     */
+    getStatuses(): ExporterStatus[];
     /**
      * Clear all registered exporters and reset state
      * (For testing and cleanup)

package/dist/observability/exporterRegistry.js

@@ -3,6 +3,7 @@
  * Manages multiple observability exporters with circuit breaker protection
  */
 import { logger } from "../utils/logger.js";
+import { exporterStatusOf } from "./exporters/baseExporter.js";
 import { AlwaysSampler } from "./sampling/samplers.js";
 /** Default timeout for exporter API calls (30 seconds) */
 const DEFAULT_EXPORT_TIMEOUT_MS = 30_000;
@@ -378,6 +379,23 @@ export class ExporterRegistry {
         }
         return total;
     }
+    /**
+     * Snapshot of every registered exporter without a network call: whether it
+     * runs, what is queued, delivered and dropped, and an open circuit breaker
+     */
+    getStatuses() {
+        return Array.from(this.exporters.entries()).map(([name, exporter]) => {
+            const status = exporterStatusOf(exporter);
+            if (this.circuitBreakers.get(name)?.state !== "open") {
+                return status;
+            }
+            return {
+                ...status,
+                healthy: false,
+                errors: [...(status.errors ?? []), "Circuit breaker open"],
+            };
+        });
+    }
     /**
      * Clear all registered exporters and reset state
      * (For testing and cleanup)