@juspay/neurolink 13.4.10 → 13.5.1

package/dist/factories/providerDescriptors.js

@@ -909,14 +909,16 @@ export function resolveDefaultDecisionProvider(credentials) {
     return DECISION_PROVIDERS.find((descriptor) => isDecisionProviderConfigured(descriptor, credentials))?.name;
 }
 /**
- * Names of the decision providers that accept images, or, with `video`, the
- * ones that accept video too: a hint that names a provider which would refuse
- * the same request is worse than none.
+ * Names of the decision providers that accept images, or, with `video` or
+ * `audio`, the ones that accept that too: a hint that names a provider which
+ * would refuse the same request is worse than none.
  */
 export function listMediaDecisionProviders(needs) {
     return DECISION_PROVIDERS.filter((descriptor) => {
         const media = descriptor.decisionLimits?.media;
-        return media !== undefined && (!needs?.video || media.video);
+        return (media !== undefined &&
+            (!needs?.video || media.video) &&
+            (!needs?.audio || media.audio !== undefined));
     }).map((descriptor) => descriptor.name);
 }
 /** "a", "a or b", "a, b or c". */

package/dist/index.d.ts

@@ -416,7 +416,7 @@ export { classifyProviderError, ModelPool, createDefaultRequestRouter, Classifie
  * if (team && team.confidence > 0.7) { route(team.choice); }
  * ```
  */
-export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, HOST_DECISION_NAMESPACE, isDecisionQuestion, readDecisionBoolean, readDecisionChoice, readDecisionScore, servesInferenceKind, } from "./utils/decisionAnswers.js";
+export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, HOST_DECISION_NAMESPACE, isDecisionQuestion, readDecisionBoolean, readDecisionChoice, readDecisionScore, readDecisionValue, servesInferenceKind, } from "./utils/decisionAnswers.js";
 export { estimateDecisionStateTokens, resolveDecisionLimitsReading, } from "./utils/decisionLimits.js";
 export { DECISION_PROVIDERS, resolveDefaultDecisionProvider, } from "./factories/providerDescriptors.js";
 export { TYPESAFE_MAX_REQUEST_TOKENS, TYPESAFE_MAX_STATE_TOKENS, } from "./providers/typesafe.js";

package/dist/index.js

@@ -633,7 +633,7 @@ export { classifyProviderError, ModelPool, createDefaultRequestRouter, Classifie
  * if (team && team.confidence > 0.7) { route(team.choice); }
  * ```
  */
-export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, HOST_DECISION_NAMESPACE, isDecisionQuestion, readDecisionBoolean, readDecisionChoice, readDecisionScore, servesInferenceKind, } from "./utils/decisionAnswers.js";
+export { decisionBooleanConfidence, decisionKey, gateDecisionBoolean, HOST_DECISION_NAMESPACE, isDecisionQuestion, readDecisionBoolean, readDecisionChoice, readDecisionScore, readDecisionValue, servesInferenceKind, } from "./utils/decisionAnswers.js";
 // The estimator the pre-flight refusal uses, and the flattening behind
 // `neurolink.decisionLimits()` — exported so a host measures a state with the
 // very function that will judge it.

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)
@@ -2694,12 +2700,14 @@ export declare class NeuroLink {
      *    many would have the WHOLE request refused, and NeuroLink's own routing
      *    would silently degrade to the heuristic — the host's problem would
      *    become NeuroLink's. A provider that declares no `maxQuestions`
-     *    (TypeSafe, XOR) takes every well-formed addition.
+     *    (TypeSafe) takes every well-formed addition. For the same reason a
+     *    question the provider cannot answer (a type it does not list, a choice
+     *    or score past its cap) is dropped on its own.
      * 4. Answers are split: the consumer sees only its own ids, exactly as it
      *    would without hooks; `onAnswers` gets the host's answers under the
      *    host's original ids plus the full result.
      *
-     * The request's `images` and `video` ride along untouched — `merged` and
+     * The request's `images`, `video` and `audio` ride along untouched — `merged` and
      * the wire call spread the request, and only `state`, the questions and
      * the result are cloned — so an XOR request keeps its Buffers and its
      * result keeps `mediaBytes`.
@@ -2712,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

@@ -37,7 +37,7 @@ import { describeDecisionProviderKeys, PROVIDER_ALIAS_INDEX, PROVIDER_DESCRIPTOR
 import { describeSTTProviderKeys, getSTTProviderDescriptor, listConfiguredSTTProviders, resolveCallSTTEndpoints, resolveDefaultSTTProvider, resolveSTTProviderName, } from "./factories/sttDescriptors.js";
 import { MAX_PARALLEL_DECISION_BATCHES, mergeDecisionResults, splitDecisionRequest, } from "./utils/decisionBatches.js";
 import { decisionKey, HOST_DECISION_NAMESPACE, isHostDecisionKey, snapshotDecisionQuestion, stripHostAnswers, } from "./utils/decisionAnswers.js";
-import { resolveDecisionLimitsReading } from "./utils/decisionLimits.js";
+import { resolveDecisionLimitsReading, unsupportedDecisionQuestion, } from "./utils/decisionLimits.js";
 import { isDirectTTSRequest, resolveRequestKind, } from "./core/resolveRequestKind.js";
 import { createToolEventPayload } from "./core/toolEvents.js";
 import { ProviderFactory } from "./factories/providerFactory.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;
@@ -14046,12 +14094,14 @@ Current user's request: ${currentInput}`;
      *    many would have the WHOLE request refused, and NeuroLink's own routing
      *    would silently degrade to the heuristic — the host's problem would
      *    become NeuroLink's. A provider that declares no `maxQuestions`
-     *    (TypeSafe, XOR) takes every well-formed addition.
+     *    (TypeSafe) takes every well-formed addition. For the same reason a
+     *    question the provider cannot answer (a type it does not list, a choice
+     *    or score past its cap) is dropped on its own.
      * 4. Answers are split: the consumer sees only its own ids, exactly as it
      *    would without hooks; `onAnswers` gets the host's answers under the
      *    host's original ids plus the full result.
      *
-     * The request's `images` and `video` ride along untouched — `merged` and
+     * The request's `images`, `video` and `audio` ride along untouched — `merged` and
      * the wire call spread the request, and only `state`, the questions and
      * the result are cloned — so an XOR request keeps its Buffers and its
      * result keeps `mediaBytes`.
@@ -14064,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
@@ -14092,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);
         }
@@ -14145,7 +14198,7 @@ Current user's request: ${currentInput}`;
                         model: merged.model,
                         credentials: merged.credentials,
                     });
-                    // A provider without a question-count cap (TypeSafe, XOR) takes
+                    // A provider without a question-count cap (TypeSafe) takes
                     // every well-formed addition; its token/byte limits still apply
                     // and are what `decisionLimits()` reports for sizing.
                     const room = limits?.maxQuestions !== undefined
@@ -14155,6 +14208,7 @@ Current user's request: ${currentInput}`;
                         ...ownQuestions,
                     };
                     let invalidCount = 0;
+                    let unsupportedCount = 0;
                     let overflowCount = 0;
                     for (const [hostId, proposal] of proposedEntries) {
                         // The wire carries a snapshot of the host's question, never the
@@ -14164,6 +14218,12 @@ Current user's request: ${currentInput}`;
                             invalidCount += 1;
                             continue;
                         }
+                        // A question the provider cannot read would have the whole
+                        // request refused, NeuroLink's own questions with it.
+                        if (unsupportedDecisionQuestion(question, limits) !== undefined) {
+                            unsupportedCount += 1;
+                            continue;
+                        }
                         if (hostIdByWireId.size >= room) {
                             overflowCount += 1;
                             continue;
@@ -14175,6 +14235,9 @@ Current user's request: ${currentInput}`;
                     if (invalidCount > 0) {
                         logger.warn(`[Decision] dropped ${invalidCount} malformed host question(s) for site "${site}"`);
                     }
+                    if (unsupportedCount > 0) {
+                        logger.warn(`[Decision] dropped ${unsupportedCount} host question(s) for site "${site}" that ${limits?.provider ?? "the decision provider"} cannot answer`);
+                    }
                     if (overflowCount > 0 && limits) {
                         logger.warn(`[Decision] dropped ${overflowCount} host question(s) for site "${site}": ${limits.provider} accepts ${limits.maxQuestions} per request and NeuroLink asks ${ownCount}`);
                     }
@@ -14306,6 +14369,7 @@ Current user's request: ${currentInput}`;
                 "ai.provider": providerName,
                 "decision.question_count": questionCount,
                 "decision.images.count": options.images?.length ?? 0,
+                "decision.audio.count": options.audio === undefined ? 0 : 1,
                 ...siteSpanAttributes,
             },
         }, async (otelSpan) => {
@@ -14335,6 +14399,7 @@ Current user's request: ${currentInput}`;
                 "ai.model": options.model ?? "",
                 "decision.question_count": questionCount,
                 "decision.images.count": options.images?.length ?? 0,
+                "decision.audio.count": options.audio === undefined ? 0 : 1,
                 ...siteSpanAttributes,
             }, parentSpanId, traceId);
             try {
@@ -14348,6 +14413,7 @@ Current user's request: ${currentInput}`;
                     questions: options.questions,
                     images: options.images,
                     video: options.video,
+                    audio: options.audio,
                     model: options.model,
                     signal: options.signal,
                     timeoutMs: options.timeoutMs,
@@ -14404,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)