@juspay/neurolink 12.59.0 → 13.0.0

package/dist/types/observability.d.ts

@@ -4,29 +4,8 @@
  * to enable telemetry and observability features in Neurolink SDK
  */
 import type { AttributeValue } from "@opentelemetry/api";
+import type { JsonValue, RawUsageObject, Unknown } from "./common.js";
 import type { SpanData } from "./span.js";
-/**
- * Trace name format for Langfuse traces
- *
- * Controls how userId and operationName are combined to form the trace name.
- * Can be a predefined format string or a custom function.
- *
- * @example
- * // Predefined formats:
- * "userId:operationName" → "user@email.com:ai.streamText"
- * "operationName:userId" → "ai.streamText:user@email.com"
- * "operationName" → "ai.streamText"
- * "userId" → "user@email.com" (legacy)
- *
- * @example
- * // Custom function:
- * (ctx) => `[${ctx.operationName}] ${ctx.userId}`
- * // → "[ai.streamText] user@email.com"
- */
-export type TraceNameFormat = "userId:operationName" | "operationName:userId" | "operationName" | "userId" | ((context: {
-    userId?: string;
-    operationName?: string;
-}) => string);
 /**
  * Standard GenAI semantic convention attributes from OpenTelemetry
  * These are the attributes that Vercel AI SDK's experimental_telemetry creates
@@ -55,121 +34,57 @@ export type LangfuseSpanAttributes = {
     [key: string]: AttributeValue | undefined;
 };
 /**
- * Langfuse observability configuration
+ * @description Langfuse exporter options. Every field falls back to its `LANGFUSE_*` environment variable when omitted.
  */
-export type LangfuseConfig = {
-    /** Whether Langfuse is enabled */
-    enabled: boolean;
-    /** Langfuse public key */
-    publicKey: string;
-    /**
-     * Langfuse secret key
-     * @sensitive
-     * WARNING: This is a sensitive credential. Handle securely.
-     * Do NOT log, expose, or share this key. Follow best practices for secret management.
-     */
-    secretKey: string;
-    /** Langfuse base URL (default: https://cloud.langfuse.com) */
+export type NeurolinkLangfuseConfig = {
+    /** 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 (e.g., dev, staging, prod) */
+    /** Environment name; defaults to `LANGFUSE_TRACING_ENVIRONMENT`. */
     environment?: string;
-    /** Release/version identifier */
+    /** Release identifier; defaults to `LANGFUSE_RELEASE`. */
     release?: string;
-    /** Optional default user id to attach to spans */
-    userId?: string;
-    /** Optional default session id to attach to spans */
-    sessionId?: string;
-    /**
-     * If true, NeuroLink will NOT create or register its own TracerProvider.
-     * Instead, it will only create the LangfuseSpanProcessor and ContextEnricher,
-     * which the parent application must add to its own TracerProvider.
-     *
-     * Use this when your application already has OpenTelemetry instrumentation.
-     *
-     * @default false
-     */
-    useExternalTracerProvider?: boolean;
-    /**
-     * If true, NeuroLink will automatically detect if a TracerProvider is already
-     * registered globally and skip its own registration to avoid conflicts.
-     *
-     * This is a convenience option that combines well with useExternalTracerProvider.
-     *
-     * @default false
-     */
-    autoDetectExternalProvider?: boolean;
-    /**
-     * If true, NeuroLink will NOT register its own LangfuseSpanProcessor with the
-     * global TracerProvider when using external provider mode. Only the ContextEnricher
-     * will be registered. Use this when the host application already registers a
-     * LangfuseSpanProcessor (e.g., via a DeferredSpanProcessor) to prevent duplicate
-     * trace exports to Langfuse.
-     *
-     * @default false
-     */
-    skipLangfuseSpanProcessor?: boolean;
-    /**
-     * Enable auto-detection of operation names from span names.
-     *
-     * When true (default), AI operation spans (ai.streamText, ai.generateText, etc.)
-     * will have their operation name automatically extracted and included in the
-     * trace name.
-     *
-     * @default true
-     *
-     * @example
-     * // With auto-detection enabled (default):
-     * // Span "ai.streamText" + userId "user@email.com"
-     * // → Trace name: "user@email.com:ai.streamText"
-     *
-     * @example
-     * // With auto-detection disabled:
-     * // → Trace name: "user@email.com" (legacy behavior)
-     */
-    autoDetectOperationName?: boolean;
-    /**
-     * Format for trace names in Langfuse.
-     *
-     * Controls how userId and operationName are combined to form the trace name.
-     * Can be a predefined format string or a custom function for full control.
-     *
-     * @default "userId:operationName"
-     *
-     * @example
-     * // Predefined formats:
-     * traceNameFormat: "userId:operationName" // "user@email.com:ai.streamText"
-     * traceNameFormat: "operationName:userId" // "ai.streamText:user@email.com"
-     * traceNameFormat: "operationName"        // "ai.streamText"
-     * traceNameFormat: "userId"               // "user@email.com" (legacy)
-     *
-     * @example
-     * // Custom function:
-     * traceNameFormat: (ctx) => `[${ctx.operationName || 'unknown'}] ${ctx.userId}`
-     * // → "[ai.streamText] user@email.com"
-     */
-    traceNameFormat?: TraceNameFormat;
+    /** Applied to input, output and metadata before they leave the process. */
+    mask?: (params: {
+        data: JsonValue;
+    }) => JsonValue;
+    /** `"immediate"` sends every span as it ends; `"batched"` (default) queues them. */
+    exportMode?: "batched" | "immediate";
+    /** Spans queued before a batch is sent; defaults to 15. */
+    flushAt?: number;
+    /** Seconds between batch sends; defaults to 5. */
+    flushInterval?: number;
 };
 /**
- * OpenTelemetry configuration
+ * @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.
  */
-export type OpenTelemetryConfig = {
-    /** Whether OpenTelemetry is enabled */
-    enabled: boolean;
-    /** OTLP endpoint URL */
-    endpoint?: string;
-    /** Service name for traces */
-    serviceName?: string;
-    /** Service version */
-    serviceVersion?: string;
+export type ObservabilityConfig = {
+    /** `false` disables Langfuse, `true` or an options object enables it. */
+    langfuse?: boolean | NeurolinkLangfuseConfig;
 };
 /**
- * Complete observability configuration for Neurolink SDK
+ * @description Per-call trace attributes propagated to every span created inside the call.
  */
-export type ObservabilityConfig = {
-    /** Langfuse configuration */
-    langfuse?: LangfuseConfig;
-    /** OpenTelemetry configuration */
-    openTelemetry?: OpenTelemetryConfig;
+export type NeurolinkTraceContext = {
+    /** End user the trace belongs to. */
+    userId?: string | null;
+    /** Session that groups related traces. */
+    sessionId?: string | null;
+    /** Conversation identifier, recorded as trace metadata. */
+    conversationId?: string | null;
+    /** Request identifier, recorded as trace metadata. */
+    requestId?: string | null;
+    /** Trace name shown in Langfuse. */
+    traceName?: string | null;
+    /** Trace tags. */
+    tags?: string[];
+    /** Trace metadata; values up to 200 characters once stringified are on every observation, longer values and arrays only on the trace. */
+    metadata?: Record<string, SpanContent | undefined>;
+    /** Name of the root observation of this `generate` or `stream` call; not propagated to child observations and not the trace name. */
+    observationName?: string | null;
 };
 /**
  * Retry policy type for observability exporters.
@@ -225,45 +140,93 @@ export type TraceView = {
     /** Overall trace status */
     status: "ok" | "error" | "partial";
 };
-/**
- * Extended context for Langfuse spans.
- * Supports all Langfuse trace attributes for rich observability.
- */
 /** A model request serialized onto a span: the system prompt plus messages, or a bare prompt. */
 export type SpanModelRequest = {
     system?: unknown;
     messages?: readonly unknown[];
     prompt?: string;
 };
-export type LangfuseContext = {
-    userId?: string | null;
-    sessionId?: string | null;
-    /** Conversation/thread identifier for grouping related traces */
-    conversationId?: string | null;
-    /** Request identifier for correlating with application logs */
-    requestId?: string | null;
-    /** Custom trace name for better organization in Langfuse UI */
-    traceName?: string | null;
-    /** Custom metadata to attach to spans */
-    metadata?: Record<string, unknown> | null;
-    /** Langfuse trace tags, set on the trace's root span (e.g. to label what a trace is for) */
-    tags?: string[] | null;
-    /**
-     * Explicit operation name (e.g., "ai.streamText", "chat", "embeddings").
-     * If set, overrides auto-detection from the span name.
-     */
-    operationName?: string | null;
-    /**
-     * Override global autoDetectOperationName setting for this context.
-     * When undefined, uses the global setting (defaults to true).
-     */
-    autoDetectOperationName?: boolean;
-    /**
-     * Custom attributes to set on all spans within this context.
-     * These attributes are propagated to every span created within the
-     * AsyncLocalStorage context.
-     */
-    customAttributes?: Record<string, string | number | boolean>;
+export type GenerationOperation = "generate" | "stream";
+/** @description Any value a span attribute can carry: JSON, or an object serialized on the way out. */
+export type SpanContent = JsonValue | object;
+/** @description Observation kinds Langfuse renders a span as. */
+export type ObservationType = "span" | "generation" | "event" | "embedding" | "agent" | "tool" | "chain" | "retriever" | "evaluator" | "guardrail";
+/** @description Severity of an observation. */
+export type ObservationLevel = "DEBUG" | "DEFAULT" | "WARNING" | "ERROR";
+/** @description Attributes stamped on an observation span by `observe`. */
+export type ObservationAttributes = {
+    input?: Unknown;
+    output?: Unknown;
+    metadata?: Record<string, SpanContent | undefined>;
+    level?: ObservationLevel;
+    statusMessage?: string;
+    completionStartTime?: Date;
+    model?: string;
+    modelParameters?: Record<string, string | number>;
+    usageDetails?: Record<string, number>;
+    costDetails?: Record<string, number>;
+};
+/** @description Trace-level input, output and per-key metadata recorded by `observeTrace`. */
+export type TraceContent = Pick<ObservationAttributes, "input" | "output"> & {
+    metadata?: Record<string, SpanContent | undefined>;
+};
+/** @description A tool call as a provider, the agentic loop or a tool execution names its fields. */
+export type AssistantToolCall = {
+    id?: string;
+    toolCallId?: string;
+    name?: string;
+    toolName?: string;
+    args?: SpanContent;
+    input?: SpanContent;
+    arguments?: SpanContent;
+    function?: {
+        name?: string;
+        arguments?: SpanContent;
+    };
+};
+/** @description A model response split into text, reasoning and tool calls. */
+export type AssistantReply = {
+    text?: string;
+    reasoning?: string;
+    toolCalls?: AssistantToolCall[];
+};
+/** @description A model response as plain text, a structured reply, or message or content-part arrays. */
+export type AssistantOutput = string | AssistantReply | object[];
+/** @description A tool call in OpenAI chat shape, as Langfuse renders it. */
+export type ObservationToolCall = {
+    id?: string;
+    type: "function";
+    function: {
+        name?: string;
+        arguments: string;
+    };
+};
+/**
+ * @description One model request as a Langfuse generation. Every field is optional so the request half and the response half can be recorded separately.
+ */
+export type GenerationRecord = {
+    /** Public API the call serves; inferred from the enclosing span when unset. */
+    operation?: GenerationOperation;
+    /** Provider name, used with the model to price the call. */
+    provider?: string;
+    /** Model the request asked for. */
+    model?: string;
+    /** Model the response says served it, when the API reports one. */
+    responseModel?: string;
+    /** Sampling and thinking parameters sent; undefined entries are dropped. */
+    modelParameters?: Record<string, string | number | undefined>;
+    /** System prompt and messages, or the bare prompt, sent. */
+    input?: SpanModelRequest;
+    /** Text and tool calls returned. */
+    output?: AssistantOutput;
+    /** Token usage in any naming convention `extractTokenUsage` reads. */
+    usage?: RawUsageObject | null;
+    /** Provider finish reason. */
+    finishReason?: string;
+    /** Whether the caller aborted the call before it finished. */
+    aborted?: boolean;
+    /** When the first chunk of a streamed response arrived. */
+    completionStartTime?: Date;
 };
 /**
  * Latency statistics with percentile calculations
@@ -426,6 +389,10 @@ export type SpanOptions = {
     tracer: import("@opentelemetry/api").Tracer;
     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;
 };
 /** Trace + parent span IDs used to correlate metric records with spans. */
 export type MetricsTraceContext = {

package/dist/types/providers.d.ts

@@ -2797,3 +2797,18 @@ export type VertexAnthropicContentBlock = {
     tool_use_id: string;
     content: string;
 };
+/** Content block as seen by the trace sanitizer; media blocks carry a `source`. */
+export type AnthropicTraceBlock = {
+    type: string;
+    source?: string | {
+        type?: string;
+        media_type?: string;
+        data?: string;
+        url?: string;
+    };
+};
+/** Anthropic message shape accepted by the trace sanitizer. */
+export type AnthropicTraceMessage = {
+    role: string;
+    content: string | AnthropicTraceBlock[];
+};

package/dist/types/proxy.d.ts

@@ -1,4 +1,6 @@
-import type { ProxyTokenBudgetSnapshot } from "./proxyBudget.js";
+import type { ProxyTokenBudgetLease, ProxyTokenBudgetSnapshot } from "./proxyBudget.js";
+import type { CodexRuntimeAccount } from "./codex.js";
+import type { JsonObject, JsonValue } from "./common.js";
 import type { ProxyContextEvidence, ProxyPreparedContext } from "./proxyContext.js";
 /**
  * Proxy type definitions for NeuroLink
@@ -27,7 +29,7 @@ import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
 import type { ProxyTracer } from "../proxy/proxyTracer.js";
 import type { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES } from "../proxy/routingEvidence.js";
 import type { CodexFallbackTarget, FallbackEntry, ModelMapping, ProxyRoutingConfig, CloakingConfig } from "./subscription.js";
-import type { RouteDeprecation } from "./server.js";
+import type { RouteDeprecation, ServerContext } from "./server.js";
 import type { StoredOAuthTokens } from "./auth.js";
 /**
  * Type describing the ModelRouter contract.
@@ -1033,6 +1035,37 @@ export type CodexFinalLogExtra = Partial<Pick<RequestLogEntry, "errorType" | "er
 export type CodexOutboundServedAttribution = Required<Pick<RequestLogEntry, "account" | "accountType" | "provider" | "model">> & Pick<RequestLogEntry, "accountKey">;
 /** Additional fields recorded for each upstream Codex account attempt. */
 export type CodexAttemptLogExtra = Partial<Pick<RequestAttemptLogEntry, "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheCreationTokens" | "reasoningTokens" | "inputIncludesCachedTokens" | "errorType" | "errorMessage" | "errorCode" | "transportScope" | "retryable" | "rateLimitKind" | "cooldownReason" | "quotaResetAt" | "quotaScope">>;
+/** Mutable per-request state shared by the Codex request helpers. */
+export type CodexRequestState = {
+    body: JsonObject;
+    bodyStr: string;
+    contextPreflight?: ProxyContextEvidence;
+    budgetLease?: ProxyTokenBudgetLease;
+    budgetDispatched: boolean;
+    finalOutcomeRecorded: boolean;
+};
+/** Everything the Codex request helpers need to serve and account one turn. */
+export type CodexRequestRuntime = {
+    ctx: ServerContext;
+    model: string;
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    isFallbackRequest: boolean;
+    state: CodexRequestState;
+    runtimeConfigProvider?: ProxyRuntimeConfigProvider;
+    loopbackPort?: number;
+    internalDispatch?: (request: Request) => Response | Promise<Response>;
+    settleBudget: (actualTokens?: number) => Promise<void>;
+    recordFinalOutcome: (account: CodexRuntimeAccount | undefined, responseStatus: number, extra?: CodexFinalLogExtra) => Promise<void>;
+    writeAttempt: (account: CodexRuntimeAccount, attempt: number, startedAt: number, responseStatus: number, extra?: CodexAttemptLogExtra) => void;
+};
+/** Failure details recorded when a Codex account is rotated past. */
+export type CodexRotationFailure = {
+    lastFailure: CodexFinalLogExtra;
+    lastErrorStatus: number;
+    lastErrorCode: string | undefined;
+    lastErrorMessage: string;
+};
 /** Minimal persistence contract needed by Codex rotating-token refreshes. */
 export type CodexRefreshTokenStore = {
     peekTokens(provider: string): Promise<StoredOAuthTokens | null>;
@@ -1928,6 +1961,11 @@ export type ResponseInfoContext = {
     stopSequence?: string;
     /** Names of the tools the model actually invoked (tool_use blocks). */
     toolCalls?: string[];
+    output?: JsonValue | Array<{
+        type?: string;
+        toolName?: string;
+    }>;
+    firstOutputAt?: number;
 };
 /** Context recorded when an account is selected for a proxy request. */
 export type AccountSelectionContext = {
@@ -2445,6 +2483,7 @@ export type CodexStreamEvidence = {
     errorType?: string;
     errorMessage?: string;
     errorCode?: string;
+    response?: JsonObject;
 };
 /** Validated account-routing evidence joined to a final request log. */
 export type ProxyAnalysisRoutingRecord = {

package/dist/utils/anthropicTraceSanitizer.d.ts

@@ -1,7 +1,7 @@
-import type { VertexAnthropicMessage } from "../types/index.js";
+import type { AnthropicTraceMessage } from "../types/index.js";
 /**
  * Strips base64 image/PDF payloads from Anthropic messages before they go on a
  * trace attribute — one screenshot would otherwise be megabytes on a span.
  * Other block types pass through; the serializer still applies its length cap.
  */
-export declare function sanitizeAnthropicMessagesForTrace(messages: VertexAnthropicMessage[]): Array<Record<string, unknown>>;
+export declare function sanitizeAnthropicMessagesForTrace(messages: AnthropicTraceMessage[]): Array<Record<string, unknown>>;

package/dist/utils/anthropicTraceSanitizer.js

@@ -11,7 +11,9 @@ export function sanitizeAnthropicMessagesForTrace(messages) {
         return {
             role: message.role,
             content: message.content.map((block) => {
-                if (block.type === "image" || block.type === "document") {
+                if ((block.type === "image" || block.type === "document") &&
+                    typeof block.source === "object" &&
+                    typeof block.source.data === "string") {
                     return {
                         type: block.type,
                         media_type: block.source.media_type,

package/dist/utils/conversationMemory.js

@@ -143,7 +143,7 @@ export async function getConversationMessages(conversationMemory, options) {
         });
         return [];
     }
-    return memoryTracer.startActiveSpan("neurolink.conversation.getMessages", {
+    return memoryTracer.startActiveSpan("conversation.getMessages", {
         kind: SpanKind.INTERNAL,
         attributes: {
             "session.id": sessionId,
@@ -174,7 +174,7 @@ export async function getConversationMessages(conversationMemory, options) {
             const repair = repairToolPairs(filtered);
             const messages = repair.messages;
             if (repair.repaired) {
-                span.setAttribute("neurolink.memory.tool_pairs_repaired", repair.orphanedCallsFixed + repair.orphanedResultsFixed);
+                span.setAttribute("memory.tool_pairs_repaired", repair.orphanedCallsFixed + repair.orphanedResultsFixed);
                 logger.debug("[conversationMemoryUtils] Repaired orphaned tool pairs on read", {
                     sessionId,
                     orphanedCallsFixed: repair.orphanedCallsFixed,
@@ -188,7 +188,7 @@ export async function getConversationMessages(conversationMemory, options) {
                 // signal. The warn log is deduped per session so a long-lived
                 // polluted conversation only generates one log line, not one per
                 // turn (would otherwise be noisy at scale).
-                span.setAttribute("neurolink.memory.polluted_turns_dropped", droppedCount);
+                span.setAttribute("memory.polluted_turns_dropped", droppedCount);
                 const alreadyWarned = pollutedWarnedSessions.has(sessionId);
                 if (!alreadyWarned) {
                     if (pollutedWarnedSessions.size >= POLLUTED_WARN_DEDUP_MAX) {
@@ -364,7 +364,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
             });
         }
     }
-    await memoryTracer.startActiveSpan("neurolink.conversation.storeTurn", {
+    await memoryTracer.startActiveSpan("conversation.storeTurn", {
         kind: SpanKind.INTERNAL,
         attributes: {
             "session.id": sessionId,

package/dist/utils/fileDetector.js

@@ -278,7 +278,7 @@ export class FileDetector {
         const inputFilename = FileDetector.deriveInputFilename(input);
         const inputSizeBytes = FileDetector.deriveInputSize(input);
         return withSpan({
-            name: "neurolink.file.detect_and_process",
+            name: "file.detect_and_process",
             tracer: tracers.file,
             attributes: {
                 [ATTR.FILE_NAME]: inputFilename,

package/dist/utils/messageBuilder.js

@@ -1318,7 +1318,7 @@ export async function processUnifiedFilesArray(options, maxSize, provider) {
     const totalFiles = pending.length;
     const files = pending;
     return withSpan({
-        name: "neurolink.file.process_all",
+        name: "file.process_all",
         tracer: tracers.file,
         attributes: {
             [ATTR.FILE_TOTAL_COUNT]: totalFiles,

package/dist/utils/noOutputSentinel.d.ts

@@ -38,25 +38,13 @@ underlyingError?: unknown): Promise<{
     error: Error;
 } | null>;
 /**
- * Reviewer follow-up: every provider's post-stream NoOutput detect must
- * stamp the active OTel span so Pipeline B (`ContextEnricher.onEnd()` →
- * `applyNonErrorLangfuseLevel`) surfaces a WARNING-level Langfuse
- * observation with the enriched status message. Without this, only
- * `StreamHandler`-based providers produced the rich telemetry; the
- * provider-specific paths (openAI, openaiCompatible, litellm,
- * huggingFace, openRouter, anthropic) yielded the sentinel
- * to direct stream consumers but Pipeline B saw nothing.
- *
- * Stamps three attributes:
- *   - `neurolink.no_output = true` (Pipeline B trigger)
- *   - `langfuse.status_message` (enriched, with finishReason + tokens)
- *   - `neurolink.no_output.finish_reason` (raw finish reason)
- *
- * Safe to call when tracing isn't initialized — silently no-ops.
+ * Marks the active span as a no-output stream so Langfuse shows a WARNING
+ * observation with the enriched status message. Safe to call when tracing
+ * isn't initialized — silently no-ops.
  */
 export declare function stampNoOutputSpan(sentinel: StreamNoOutputSentinel): void;
 /**
- * Build the OTel `langfuse.status_message` summary string for a no-output
+ * Build the OTel `langfuse.observation.status_message` summary string for a no-output
  * stream. Used by `StreamHandler.createTextStream` and any future provider
  * that wants to stamp the active span with the same enriched message.
  *

package/dist/utils/noOutputSentinel.js

@@ -1,4 +1,6 @@
+import { LangfuseOtelSpanAttributes } from "@langfuse/tracing";
 import { trace, context as otelContext } from "@opentelemetry/api";
+import { observationLevel } from "../telemetry/observation.js";
 import { NoOutputGeneratedError } from "./generationErrors.js";
 export async function buildNoOutputSentinel(error, result, 
 /**
@@ -129,38 +131,20 @@ underlyingError) {
     }
 }
 /**
- * Reviewer follow-up: every provider's post-stream NoOutput detect must
- * stamp the active OTel span so Pipeline B (`ContextEnricher.onEnd()` →
- * `applyNonErrorLangfuseLevel`) surfaces a WARNING-level Langfuse
- * observation with the enriched status message. Without this, only
- * `StreamHandler`-based providers produced the rich telemetry; the
- * provider-specific paths (openAI, openaiCompatible, litellm,
- * huggingFace, openRouter, anthropic) yielded the sentinel
- * to direct stream consumers but Pipeline B saw nothing.
- *
- * Stamps three attributes:
- *   - `neurolink.no_output = true` (Pipeline B trigger)
- *   - `langfuse.status_message` (enriched, with finishReason + tokens)
- *   - `neurolink.no_output.finish_reason` (raw finish reason)
- *
- * Safe to call when tracing isn't initialized — silently no-ops.
+ * Marks the active span as a no-output stream so Langfuse shows a WARNING
+ * observation with the enriched status message. Safe to call when tracing
+ * isn't initialized — silently no-ops.
  */
 export function stampNoOutputSpan(sentinel) {
-    try {
-        const activeSpan = trace.getSpan(otelContext.active());
-        if (!activeSpan) {
-            return;
-        }
-        activeSpan.setAttribute("neurolink.no_output", true);
-        activeSpan.setAttribute("langfuse.status_message", buildNoOutputStatusMessage(sentinel.metadata.finishReason, sentinel.metadata.usage));
-        activeSpan.setAttribute("neurolink.no_output.finish_reason", String(sentinel.metadata.finishReason));
-    }
-    catch {
-        // Tracing not initialized — ignore.
-    }
+    trace.getSpan(otelContext.active())?.setAttributes({
+        no_output: true,
+        "no_output.finish_reason": String(sentinel.metadata.finishReason),
+        [LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: observationLevel("no-output"),
+        [LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: buildNoOutputStatusMessage(sentinel.metadata.finishReason, sentinel.metadata.usage),
+    });
 }
 /**
- * Build the OTel `langfuse.status_message` summary string for a no-output
+ * Build the OTel `langfuse.observation.status_message` summary string for a no-output
  * stream. Used by `StreamHandler.createTextStream` and any future provider
  * that wants to stamp the active span with the same enriched message.
  *

package/dist/utils/providerRetry.js

@@ -270,7 +270,7 @@ export async function withProviderRetry(operation, span, label, sleep = sleepWit
         try {
             const result = await operation();
             // Record how many attempts it took on the span
-            span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+            span?.setAttribute("provider.total_attempts", attempt + 1);
             if (attempt > 0) {
                 logger.info(`[providerRetry] ${label} succeeded after ${attempt + 1} attempts`);
             }
@@ -282,9 +282,9 @@ export async function withProviderRetry(operation, span, label, sleep = sleepWit
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (!retryable || attempt === MAX_PROVIDER_RETRIES) {
                 // Record failure details before re-throwing
-                span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+                span?.setAttribute("provider.total_attempts", attempt + 1);
                 if (attempt > 0) {
-                    span?.setAttribute("gen_ai.provider.retries_exhausted", true);
+                    span?.setAttribute("provider.retries_exhausted", true);
                 }
                 logger.warn(`[providerRetry] ${label} failed (non-retryable or retries exhausted)`, {
                     attempt: attempt + 1,
@@ -296,7 +296,7 @@ export async function withProviderRetry(operation, span, label, sleep = sleepWit
             }
             const retryAfterMs = getRetryAfterMs(error);
             if (retryAfterMs !== undefined && retryAfterMs > MAX_RETRY_AFTER_MS) {
-                span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+                span?.setAttribute("provider.total_attempts", attempt + 1);
                 span?.addEvent("gen_ai.provider.retry_suppressed", {
                     "retry.after_ms": retryAfterMs,
                     ...(statusCode !== undefined && { "retry.status_code": statusCode }),

package/dist/voice/livekit/brain.js

@@ -56,7 +56,7 @@ export function createVoiceBrain(config) {
             systemPrompt,
             temperature,
             maxTokens,
-            context,
+            context: { ...context, tags: ["voice"] },
             // Every turn through this brain is spoken; stored messages are marked so.
             modality: "voice",
             abortSignal: signal,

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

@@ -19,4 +19,4 @@
 import type { JobContext } from "@livekit/agents";
 import type { RealtimeCallMemory, RealtimeVoiceMemoryConfig } from "../../types/index.js";
 /** Verify the call's binding and prepare its recorder; `undefined` means "no memory for this call". */
-export declare function setUpRealtimeCallMemory(ctx: Pick<JobContext, "room" | "addShutdownCallback">, config: RealtimeVoiceMemoryConfig | undefined): Promise<RealtimeCallMemory | undefined>;
+export declare function setUpRealtimeCallMemory(ctx: Pick<JobContext, "room" | "addShutdownCallback">, config: RealtimeVoiceMemoryConfig | undefined, model?: string): Promise<RealtimeCallMemory | undefined>;