@juspay/neurolink 13.5.0 → 13.6.0

package/dist/types/observability.d.ts

@@ -3,7 +3,7 @@
  * These configs are passed from the parent application (e.g., Lighthouse)
  * to enable telemetry and observability features in Neurolink SDK
  */
-import type { AttributeValue } from "@opentelemetry/api";
+import type { AttributeValue, Counter, Histogram, Meter } from "@opentelemetry/api";
 import type { JsonValue, RawUsageObject, Unknown } from "./common.js";
 import type { SpanData } from "./span.js";
 /**
@@ -37,20 +37,26 @@ export type LangfuseSpanAttributes = {
  * @description Langfuse exporter options. Every field falls back to its `LANGFUSE_*` environment variable when omitted.
  */
 export type NeurolinkLangfuseConfig = {
+    /** `false` keeps Langfuse export off although keys are present; any other value, or leaving it out, leaves it on. */
+    enabled?: boolean;
     /** Project public key; defaults to `LANGFUSE_PUBLIC_KEY`. */
     publicKey?: string;
     /** Project secret key; defaults to `LANGFUSE_SECRET_KEY`. */
     secretKey?: string;
     /** Langfuse host; defaults to `LANGFUSE_BASE_URL`, then Langfuse Cloud. */
     baseUrl?: string;
-    /** Environment name; defaults to `LANGFUSE_TRACING_ENVIRONMENT`. */
+    /** Environment name on Langfuse traces; defaults to `LANGFUSE_TRACING_ENVIRONMENT`. The OTLP resource's `deployment.environment` also falls back to `LANGFUSE_ENVIRONMENT`, then `PUBLIC_APP_ENVIRONMENT`. */
     environment?: string;
-    /** Release identifier; defaults to `LANGFUSE_RELEASE`. */
+    /** Release identifier on Langfuse traces; defaults to `LANGFUSE_RELEASE`. The OTLP resource's `service.version` also falls back to `PUBLIC_APP_VERSION`. */
     release?: string;
-    /** Applied to input, output and metadata before they leave the process. */
+    /** Applied to input, output and metadata before they are sent to Langfuse. It does not reach other exporters, the OTLP export, `getSpans()` or error text. */
     mask?: (params: {
         data: JsonValue;
     }) => JsonValue;
+    /** Leaves input and output out of what is sent to Langfuse. It does not reach other exporters, the OTLP export, `getSpans()` or error text. */
+    redactIO?: boolean;
+    /** Milliseconds a flush or shutdown waits for the Langfuse exporter before it drops what is still in flight; defaults to 3000. */
+    flushBudgetMs?: number;
     /** `"immediate"` sends every span as it ends; `"batched"` (default) queues them. */
     exportMode?: "batched" | "immediate";
     /** Spans queued before a batch is sent; defaults to 15. */
@@ -59,7 +65,26 @@ export type NeurolinkLangfuseConfig = {
     flushInterval?: number;
 };
 /**
- * @description Observability configuration for the NeuroLink SDK. Langfuse turns on automatically when `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` are set; `false` turns it off.
+ * @description Kind of connection counted by the `connections_total` metric.
+ */
+export type MetricConnectionType = "websocket" | "sse" | "http";
+/**
+ * @description The OpenTelemetry instruments behind NeuroLink's `ai_*`, `mcp_*`, `connections_total`, `response_time_ms` and `custom_*` metrics, created on one meter.
+ */
+export type AiMetricInstruments = {
+    meter: Meter;
+    requests: Counter;
+    duration: Histogram;
+    tokens: Counter;
+    cost: Counter;
+    providerErrors: Counter;
+    mcpToolCalls: Counter;
+    connections: Counter;
+    responseTime: Histogram;
+    custom: Map<string, Counter | Histogram>;
+};
+/**
+ * @description Observability configuration for the NeuroLink SDK. Langfuse turns on automatically when `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` are set and `LANGFUSE_ENABLED` is not `false`, `0`, `off` or `no`; `false` turns it off.
  */
 export type ObservabilityConfig = {
     /** `false` disables Langfuse, `true` or an options object enables it. */
@@ -387,12 +412,20 @@ export type HealthMetrics = {
 export type SpanOptions = {
     name: string;
     tracer: import("@opentelemetry/api").Tracer;
+    /** Marks the span as an observation of this type when it starts, which is what sends it to the exporters. Without it a span is exported only if its own code marks it with `observe`. */
+    observationType?: ObservationType;
     kind?: import("@opentelemetry/api").SpanKind;
     attributes?: Record<string, string | number | boolean | undefined>;
     /** Marks a thrown error as an expected skip whose Langfuse level the span set itself, so `withSpan` keeps it instead of raising ERROR. */
     expectedFailure?: (error: unknown) => boolean;
     /** Keeps the span out of the active context, so spans started inside `fn` parent to the nearest ancestor that is exported. */
     detached?: boolean;
+    /**
+     * With `detached`, lets the span be the active, exported root of its trace
+     * when no span is active, so what it wraps stays in one trace instead of
+     * each child starting its own. With an active ancestor it stays detached.
+     */
+    rootWhenOrphaned?: boolean;
 };
 /** Trace + parent span IDs used to correlate metric records with spans. */
 export type MetricsTraceContext = {

package/dist/types/proxy.d.ts

@@ -2478,6 +2478,8 @@ export type CodexStreamEvidence = {
     terminalBytes: number;
     /** Malformed, oversized or undispatched frames prevent proving output absence. */
     observationIncomplete?: boolean;
+    /** Output items past the recorded-size cap were left out of `response.output`. */
+    outputItemsOmitted?: boolean;
     firstUsefulOutputAt?: number;
     firstUsefulOutputEvent?: string;
     errorType?: string;

package/dist/types/span.d.ts

@@ -141,8 +141,24 @@ export type SpanAttributes = {
 export type SpanEvent = {
     name: string;
     timestamp: string;
+    /** When the event happened as nanoseconds since the Unix epoch (decimal string); finer than `timestamp`. */
+    timestampUnixNano?: string;
     attributes?: Record<string, unknown>;
 };
+/**
+ * Instrumentation scope that created a span
+ */
+export type SpanScope = {
+    name: string;
+    version?: string;
+};
+/**
+ * The fields an OpenTelemetry SDK 1.x span exposes where 2.x uses `parentSpanContext` and `instrumentationScope`
+ */
+export type LegacyReadableSpan = {
+    parentSpanId?: string;
+    instrumentationLibrary?: SpanScope;
+};
 /**
  * Link to related span
  */
@@ -169,8 +185,18 @@ export type SpanData = {
     startTime: string;
     /** End timestamp (ISO 8601) */
     endTime?: string;
+    /** Start as nanoseconds since the Unix epoch (decimal string); finer than `startTime` */
+    startTimeUnixNano?: string;
+    /** End as nanoseconds since the Unix epoch (decimal string); finer than `endTime` */
+    endTimeUnixNano?: string;
     /** Duration in milliseconds */
     durationMs?: number;
+    /** OpenTelemetry span kind: 0 internal, 1 server, 2 client, 3 producer, 4 consumer */
+    kind?: number;
+    /** Attributes of the resource that produced the span, such as `service.name` */
+    resource?: SpanAttributes;
+    /** Instrumentation scope that created the span */
+    scope?: SpanScope;
     /** Span status */
     status: SpanStatus;
     /** Status message (for errors) */

package/dist/types/toolResolution.d.ts

@@ -35,8 +35,12 @@ export type ResolvedToolPolicy = {
     includeBound?: string[];
     /** Denylist of tool-name patterns (exact names or `*` globs), applied after include. */
     exclude: string[];
-    /** Defer external MCP tool schemas behind the search_tools meta-tool. */
+    /** Defer tool schemas behind the search_tools meta-tool. */
     discovery: boolean;
+    /** Which tools discovery may defer. Absent means "external". */
+    discoveryScope?: "external" | "all";
+    /** Tool-name patterns (exact names or `*` globs) discovery never defers. Absent means none. */
+    discoveryAlwaysVisible?: string[];
     /** Which option/config sources contributed to this policy (telemetry/debugging). */
     sources: string[];
 };

package/dist/utils/timeout.js

@@ -352,8 +352,10 @@ export function createTimeoutController(timeout, provider, operation) {
         // from here — the setTimeout callback runs in the async context captured
         // at schedule time, which is BEFORE the AI SDK span exists. Instead we
         // rely on the AI SDK propagating the TimeoutError through its recordSpan
-        // wrapper, which sets span.status = ERROR + message. ContextEnricher's
-        // SpanStatusCode.ERROR branch then surfaces level=ERROR + status_message.
+        // wrapper, which sets span.status = ERROR + message. NeuroLink's own
+        // spans the error passes through (withGeneration, withSpan) record it
+        // in markFailure as level=ERROR + status_message, and
+        // ExporterSpanProcessor exports them.
         controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
     };
     let timer = setTimeout(fire, timeoutMs);

package/dist/voice/livekit/realtimeMcpTools.js

@@ -14,6 +14,7 @@
  *
  * See docs/features/livekit-voice-agent.md.
  */
+import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { findSchemaIssue, sanitizeToolParameters } from "./schemaSanitizer.js";
@@ -159,7 +160,10 @@ export async function buildRealtimeMcpTools(params) {
                         args: args ?? {},
                     });
                     publishEvent("tool-start", { name: mcpTool.name });
-                    observe(() => onToolStart?.({ name: mcpTool.name, args: args ?? {} }));
+                    // Concurrent calls of one tool can end in any order; the id lets the
+                    // turn record give each its own result.
+                    const callId = randomUUID();
+                    observe(() => onToolStart?.({ name: mcpTool.name, args: args ?? {}, callId }));
                     const startedAt = Date.now();
                     try {
                         // Third argument is RequestOptions; the SDK aborts the in-flight
@@ -182,6 +186,7 @@ export async function buildRealtimeMcpTools(params) {
                         publishEvent("tool-result", { name: mcpTool.name, result });
                         observe(() => onToolEnd?.({
                             name: mcpTool.name,
+                            callId,
                             ...(result.isError === true
                                 ? { error: text }
                                 : { result: text }),
@@ -195,7 +200,11 @@ export async function buildRealtimeMcpTools(params) {
                             error: error instanceof Error ? error.message : String(error),
                         });
                         publishEvent("tool-result", { name: mcpTool.name, result: null });
-                        observe(() => onToolEnd?.({ name: mcpTool.name, error: String(error) }));
+                        observe(() => onToolEnd?.({
+                            name: mcpTool.name,
+                            callId,
+                            error: String(error),
+                        }));
                         return `Tool ${mcpTool.name} failed: ${String(error)}`;
                     }
                 },

package/dist/voice/livekit/realtimeMemory.d.ts

@@ -12,12 +12,30 @@
  * The shutdown flush is registered here, before the job lifecycle installs its
  * process reaper. LiveKit starts every shutdown callback in registration order
  * and the reaper exits the process about a second later, so the flush gets a
- * budget below that second and starts first.
+ * budget below that second and starts first. The same budget bounds delivery of
+ * the call's last traces, which go out while the last writes finish.
+ *
+ * Each turn is traced as it closes, never behind the store's one-at-a-time
+ * writes, so a slow or stuck store cannot delay or lose a trace.
+ *
+ * Tracing does not depend on memory. A call with no memory still gets a
+ * recorder that only traces its turns (`setUpRealtimeCallTracing`).
  *
  * See docs/features/livekit-voice-agent.md.
  */
 import type { JobContext } from "@livekit/agents";
-import type { RealtimeCallMemory, RealtimeVoiceBackend, RealtimeVoiceMemoryConfig } from "../../types/index.js";
+import type { RealtimeCallMemory, RealtimeVoiceBackend, RealtimeVoiceMemoryConfig, VoiceTurnRecorder } from "../../types/index.js";
+/**
+ * Prepare a recorder that only traces: for a call with no usable memory. Returns
+ * `undefined` when tracing is off. Without a verified binding there is no user,
+ * so the room is the session.
+ */
+export declare function setUpRealtimeCallTracing(ctx: Pick<JobContext, "room" | "addShutdownCallback">, options?: {
+    model?: string;
+    backend?: RealtimeVoiceBackend;
+    settleMs?: number;
+    flushBudgetMs?: number;
+}): VoiceTurnRecorder | undefined;
 /**
  * Verify the call's binding and prepare its recorder; `undefined` means "no
  * memory for this call". `call` names the model and the realtime backend the

package/dist/voice/livekit/realtimeMemory.js

@@ -12,13 +12,21 @@
  * The shutdown flush is registered here, before the job lifecycle installs its
  * process reaper. LiveKit starts every shutdown callback in registration order
  * and the reaper exits the process about a second later, so the flush gets a
- * budget below that second and starts first.
+ * budget below that second and starts first. The same budget bounds delivery of
+ * the call's last traces, which go out while the last writes finish.
+ *
+ * Each turn is traced as it closes, never behind the store's one-at-a-time
+ * writes, so a slow or stuck store cannot delay or lose a trace.
+ *
+ * Tracing does not depend on memory. A call with no memory still gets a
+ * recorder that only traces its turns (`setUpRealtimeCallTracing`).
  *
  * See docs/features/livekit-voice-agent.md.
  */
 import { context, trace } from "@opentelemetry/api";
 import { AIProviderName } from "../../constants/enums.js";
-import { setLangfuseContext } from "../../services/server/ai/observability/instrumentation.js";
+import { flushOpenTelemetry, isOpenTelemetryInitialized, setLangfuseContext, } from "../../services/server/ai/observability/instrumentation.js";
+import { isLangfuseEnabled } from "../../services/server/ai/observability/langfuseSetup.js";
 import { observe, observeTrace } from "../../telemetry/observation.js";
 import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
@@ -31,7 +39,7 @@ const TRACE_PROVIDER = {
     xai: AIProviderName.XAI,
 };
 function traceTurn(turn, call) {
-    const { sessionId, userId, roomName, model, provider } = call;
+    const { sessionId, userId, roomName, model, provider = AIProviderName.VERTEX, } = call;
     try {
         setLangfuseContext({
             sessionId,
@@ -45,39 +53,62 @@ function traceTurn(turn, call) {
             const root = tracers.sdk.startSpan("realtime-turn", {
                 startTime: turn.startTime,
             });
-            observe(root, "agent", {
-                input: turn.userMessage,
-                output: turn.aiResponse,
-                level,
-            });
-            observeTrace(root, {
-                input: turn.userMessage,
-                output: turn.aiResponse,
-            });
-            const inRoot = trace.setSpan(context.active(), root);
-            const generation = tracers.generation.startSpan("realtime", { startTime: turn.startTime }, inRoot);
-            observe(generation, "generation", {
-                ...(model && { model }),
-                input: [{ role: "user", content: turn.userMessage }],
-                output: [{ role: "assistant", content: turn.aiResponse }],
-                level,
-                metadata: { provider },
-            });
-            generation.end(endTime);
-            const events = turn.events ?? [];
-            for (const start of events.filter((e) => e.type === "tool:start")) {
-                const end = events.find((e) => e.type === "tool:end" &&
-                    e.tool === start.tool &&
-                    e.seq > start.seq);
-                const tool = tracers.sdk.startSpan(String(start.tool), { startTime: start.timestamp }, inRoot);
-                observe(tool, "tool", {
-                    input: start.args,
-                    output: end?.result ?? end?.error,
-                    level: end?.success === false ? "ERROR" : undefined,
+            // The root and each child end on every path, so a failure while
+            // describing one tool cannot leave the turn open and unexported.
+            try {
+                observe(root, "agent", {
+                    input: turn.userMessage,
+                    output: turn.aiResponse,
+                    level,
                 });
-                tool.end(Math.min(end?.timestamp ?? Infinity, endTime.getTime()));
+                observeTrace(root, {
+                    input: turn.userMessage,
+                    output: turn.aiResponse,
+                });
+                const inRoot = trace.setSpan(context.active(), root);
+                const generation = tracers.generation.startSpan("realtime", { startTime: turn.startTime }, inRoot);
+                try {
+                    observe(generation, "generation", {
+                        ...(model && { model }),
+                        input: [{ role: "user", content: turn.userMessage }],
+                        output: [{ role: "assistant", content: turn.aiResponse }],
+                        level,
+                        metadata: { provider },
+                    });
+                }
+                finally {
+                    generation.end(endTime);
+                }
+                const events = turn.events ?? [];
+                const consumed = new Set();
+                for (const start of events.filter((e) => e.type === "tool:start")) {
+                    // A call id pairs overlapping calls exactly; without one, each end
+                    // is spent on the earliest unpaired start of the same tool.
+                    const end = events.find((e) => e.type === "tool:end" &&
+                        e.seq > start.seq &&
+                        !consumed.has(e.seq) &&
+                        (start.callId !== undefined
+                            ? e.callId === start.callId
+                            : e.tool === start.tool));
+                    if (end) {
+                        consumed.add(end.seq);
+                    }
+                    const tool = tracers.sdk.startSpan(String(start.tool), { startTime: start.timestamp }, inRoot);
+                    try {
+                        observe(tool, "tool", {
+                            input: start.args,
+                            output: end?.result ?? end?.error,
+                            level: end?.success === false ? "ERROR" : undefined,
+                        });
+                    }
+                    finally {
+                        tool.end(Math.min(end?.timestamp ?? Infinity, endTime.getTime()));
+                    }
+                }
+            }
+            finally {
+                root.end(endTime);
             }
-            root.end(endTime);
         });
     }
     catch (error) {
@@ -86,6 +117,71 @@ function traceTurn(turn, call) {
         });
     }
 }
+/** A tracer that spends one trace per turn id. */
+function createTurnTracer(call) {
+    const tracedTurns = new Set();
+    return (turn) => {
+        if (!tracedTurns.has(turn.turnId)) {
+            tracedTurns.add(turn.turnId);
+            traceTurn(turn, call);
+        }
+    };
+}
+/** Deliver buffered traces, giving up after `budgetMs`: the worker is reaped about a second after shutdown starts. */
+async function flushTraces(budgetMs) {
+    let timer;
+    try {
+        await Promise.race([
+            flushOpenTelemetry(),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, Math.max(0, budgetMs));
+            }),
+        ]);
+    }
+    catch (error) {
+        logger.debug("realtime.memory.traceFlushFailed", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Shutdown: close the open exchange, then deliver every trace while its writes finish, all within one budget. */
+async function flushCall(recorder, budgetMs) {
+    // flush() closes, and so traces, the open exchange before it first waits.
+    const [stats] = await Promise.all([
+        recorder.flush(budgetMs),
+        flushTraces(budgetMs),
+    ]);
+    return stats;
+}
+/**
+ * Prepare a recorder that only traces: for a call with no usable memory. Returns
+ * `undefined` when tracing is off. Without a verified binding there is no user,
+ * so the room is the session.
+ */
+export function setUpRealtimeCallTracing(ctx, options = {}) {
+    if (!isLangfuseEnabled() && !isOpenTelemetryInitialized()) {
+        return undefined;
+    }
+    const trace = createTurnTracer({
+        sessionId: ctx.room.name,
+        roomName: ctx.room.name,
+        model: options.model,
+        provider: TRACE_PROVIDER[options.backend ?? "gemini"],
+    });
+    const recorder = createVoiceTurnRecorder({
+        ...(options.settleMs !== undefined ? { settleMs: options.settleMs } : {}),
+        onClosed: trace,
+        write: () => Promise.resolve(),
+    });
+    ctx.addShutdownCallback(async () => {
+        const stats = await flushCall(recorder, options.flushBudgetMs ?? DEFAULT_FLUSH_BUDGET_MS);
+        logger.info("realtime.trace.flushed", { ...stats });
+    });
+    return recorder;
+}
 /**
  * Verify the call's binding and prepare its recorder; `undefined` means "no
  * memory for this call". `call` names the model and the realtime backend the
@@ -122,20 +218,17 @@ export async function setUpRealtimeCallMemory(ctx, config, call = {}) {
         return undefined;
     }
     let publish;
-    const tracedTurns = new Set();
+    const trace = createTurnTracer({
+        sessionId,
+        userId,
+        roomName: ctx.room.name,
+        model,
+        provider: TRACE_PROVIDER[backend],
+    });
     const recorder = createVoiceTurnRecorder({
         ...(config.settleMs !== undefined ? { settleMs: config.settleMs } : {}),
+        onClosed: trace,
         write: async (turn) => {
-            if (!tracedTurns.has(turn.turnId)) {
-                tracedTurns.add(turn.turnId);
-                traceTurn(turn, {
-                    sessionId,
-                    userId,
-                    roomName: ctx.room.name,
-                    model,
-                    provider: TRACE_PROVIDER[backend],
-                });
-            }
             const result = await neurolink.recordConversationTurn({
                 sessionId,
                 userId,
@@ -160,7 +253,7 @@ export async function setUpRealtimeCallMemory(ctx, config, call = {}) {
         },
     });
     ctx.addShutdownCallback(async () => {
-        const stats = await recorder.flush(config.flushBudgetMs ?? DEFAULT_FLUSH_BUDGET_MS);
+        const stats = await flushCall(recorder, config.flushBudgetMs ?? DEFAULT_FLUSH_BUDGET_MS);
         logger.info("realtime.memory.flushed", { ...stats });
     });
     let seed = [];

package/dist/voice/livekit/realtimeVoiceAgent.js

@@ -23,7 +23,7 @@ import { createRealtimeLlm, requireXaiApiKey } from "./realtimeModel.js";
 import { readCallContextFromRoom } from "./roomContext.js";
 import { attachRealtimeEventBridge } from "./realtimeEventBridge.js";
 import { buildRealtimeMcpTools } from "./realtimeMcpTools.js";
-import { setUpRealtimeCallMemory } from "./realtimeMemory.js";
+import { setUpRealtimeCallMemory, setUpRealtimeCallTracing, } from "./realtimeMemory.js";
 const realtimeLogEventSchema = z.object({
     level: z.enum(["debug", "info", "warn", "error"]),
     message: z.string(),
@@ -219,6 +219,18 @@ export function defineRealtimeVoiceAgent(config = {}) {
             model: cfg.model,
             backend: cfg.backend,
         });
+        // Tracing does not depend on memory: a call without it is still traced.
+        const recorder = memory?.recorder ??
+            setUpRealtimeCallTracing(ctx, {
+                model: cfg.model,
+                backend: cfg.backend,
+                ...(memoryConfig?.settleMs !== undefined
+                    ? { settleMs: memoryConfig.settleMs }
+                    : {}),
+                ...(memoryConfig?.flushBudgetMs !== undefined
+                    ? { flushBudgetMs: memoryConfig.flushBudgetMs }
+                    : {}),
+            });
         await installRealtimeJobLifecycle(ctx, cfg);
         const { voice } = await import("@livekit/agents");
         const realtimeLlm = await createRealtimeLlm(cfg);
@@ -249,10 +261,10 @@ export function defineRealtimeVoiceAgent(config = {}) {
                         xContext,
                         publishEvent: bridge.publishEvent,
                         requestConfirmation: bridge.requestConfirmation,
-                        ...(memory
+                        ...(recorder
                             ? {
-                                onToolStart: (call) => memory.recorder.toolStart(call),
-                                onToolEnd: (call) => memory.recorder.toolEnd(call),
+                                onToolStart: (call) => recorder.toolStart(call),
+                                onToolEnd: (call) => recorder.toolEnd(call),
                             }
                             : {}),
                     });
@@ -319,7 +331,7 @@ export function defineRealtimeVoiceAgent(config = {}) {
                                 });
                             }
                             bridge.publishEvent("text", { delta: chunk });
-                            memory?.recorder.assistantDelta(chunk);
+                            recorder?.assistantDelta(chunk);
                         }
                     }
                 }
@@ -358,7 +370,7 @@ export function defineRealtimeVoiceAgent(config = {}) {
                 text: ev.transcript,
                 final: ev.isFinal,
             });
-            memory?.recorder.userTranscript({
+            recorder?.userTranscript({
                 text: ev.transcript,
                 final: ev.isFinal,
             });
@@ -379,7 +391,7 @@ export function defineRealtimeVoiceAgent(config = {}) {
                 // The id the stored messages carry, so a client can merge its live
                 // copy of the turn with history instead of showing it twice.
                 bridge.publishEvent("done", memory ? { turnId: ev.item.id } : {});
-                memory?.recorder.assistantMessage({
+                recorder?.assistantMessage({
                     id: ev.item.id,
                     text: ev.item.textContent,
                     interrupted: ev.item.interrupted,
@@ -398,7 +410,7 @@ export function defineRealtimeVoiceAgent(config = {}) {
         bridge.publishEvent("status", { state: "listening" });
         if (cfg.greeting.trim().length > 0) {
             logger.info("realtime.session.greeting", { ms: sinceConnect() });
-            memory?.recorder.expectGreeting();
+            recorder?.expectGreeting();
             session.generateReply({ instructions: cfg.greeting });
         }
     }

package/dist/voice/livekit/turnRecorder.js

@@ -102,6 +102,18 @@ async function writeWithRetry(record, context) {
         /* a failure sink must never break the call */
     }
 }
+/** The stored form of a closed exchange. */
+function turnRecord(exchange) {
+    return {
+        turnId: exchange.turnId,
+        userMessage: exchange.user,
+        aiResponse: exchange.assistant,
+        interrupted: exchange.interrupted,
+        callEnded: exchange.callEnded,
+        startTime: new Date(exchange.startedAt),
+        ...(exchange.events.length > 0 ? { events: exchange.events } : {}),
+    };
+}
 /** Create a recorder for one call. */
 export function createVoiceTurnRecorder(options) {
     const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
@@ -165,15 +177,14 @@ export function createVoiceTurnRecorder(options) {
         });
     }
     function finishExchange(exchange) {
-        enqueue({
-            turnId: exchange.turnId,
-            userMessage: exchange.user,
-            aiResponse: exchange.assistant,
-            interrupted: exchange.interrupted,
-            callEnded: exchange.callEnded,
-            startTime: new Date(exchange.startedAt),
-            ...(exchange.events.length > 0 ? { events: exchange.events } : {}),
-        });
+        const record = turnRecord(exchange);
+        try {
+            options.onClosed?.(record);
+        }
+        catch {
+            /* an observer of closed exchanges must never break the call */
+        }
+        enqueue(record);
     }
     function syntheticTurnId() {
         syntheticTurns += 1;
@@ -297,6 +308,7 @@ export function createVoiceTurnRecorder(options) {
             open.events.push(nextEvent("tool:start", {
                 tool: call.name,
                 toolName: call.name,
+                ...(call.callId !== undefined ? { callId: call.callId } : {}),
                 ...(call.args !== undefined
                     ? { args: boundedPayload(call.args) }
                     : {}),
@@ -309,6 +321,7 @@ export function createVoiceTurnRecorder(options) {
             open.events.push(nextEvent("tool:end", {
                 tool: call.name,
                 toolName: call.name,
+                ...(call.callId !== undefined ? { callId: call.callId } : {}),
                 success: call.error === undefined,
                 ...(call.error !== undefined
                     ? { error: boundedText(call.error) }

package/dist/workflow/core/ensembleExecutor.js

@@ -23,6 +23,7 @@ export async function executeEnsemble(options) {
     return withSpan({
         name: "neurolink.workflow.ensemble.execute",
         tracer: tracers.workflow,
+        observationType: "span",
         attributes: {
             "workflow.model_count": options.models.length,
             "workflow.parallelism": options.executionConfig?.parallelism ?? 10,
@@ -318,6 +319,7 @@ export async function executeModelGroups(groups, prompt, _executionConfig, syste
     return withSpan({
         name: "neurolink.workflow.layers.execute",
         tracer: tracers.workflow,
+        observationType: "span",
         attributes: {
             "workflow.group_count": groups.length,
             "workflow.total_models": groups.reduce((n, g) => n + g.models.length, 0),

package/dist/workflow/core/judgeScorer.js

@@ -23,6 +23,7 @@ export async function scoreEnsemble(options) {
     return withSpan({
         name: "neurolink.workflow.judge.score",
         tracer: tracers.workflow,
+        observationType: "span",
         attributes: {
             "workflow.judges_count": options.judges.length,
             "workflow.responses_count": options.responses.length,

package/dist/workflow/core/responseConditioner.js

@@ -23,6 +23,7 @@ export async function conditionResponse(options) {
     return withSpan({
         name: "neurolink.workflow.response.condition",
         tracer: tracers.workflow,
+        observationType: "span",
         attributes: {
             "workflow.conditioning.enabled": Boolean(options.config?.useConfidence),
             "workflow.conditioning.has_synthesis_model": Boolean(options.config?.synthesisModel),