@juspay/neurolink 13.7.0 → 13.8.1

package/dist/cli/commands/serve.js

@@ -224,6 +224,11 @@ export class ServeCommandFactory {
                     .option("cors", {
                     type: "boolean",
                     description: "Enable CORS middleware (default: true)",
+                })
+                    .option("max-upload", {
+                    type: "string",
+                    alias: "maxUpload",
+                    description: "Largest raw upload the server accepts (multipart / audio bodies), e.g. 64mb (default)",
                 })
                     .option("cors-origin", {
                     type: "array",
@@ -418,7 +423,12 @@ export class ServeCommandFactory {
                     : (fileConfig.rateLimit?.maxRequests ??
                         defaultConfig.rateLimit.maxRequests),
             },
-            bodyParser: fileConfig.bodyParser,
+            bodyParser: argv.maxUpload?.trim()
+                ? {
+                    ...(fileConfig.bodyParser ?? {}),
+                    rawMaxSize: argv.maxUpload.trim(),
+                }
+                : fileConfig.bodyParser,
             logging: fileConfig.logging,
             // Transcription of a long recording through a remote engine can take
             // longer than the 30 s default, so the request timeout is also

package/dist/cli/commands/transcribe.js

@@ -147,7 +147,8 @@ function buildCorrection(argv, hasDictionary) {
         correction.transliterate = argv.transliterate;
     }
     if (argv.secondOpinion) {
-        correction.secondOpinion = { provider: argv.secondOpinion };
+        correction.secondOpinion =
+            argv.secondOpinion === "auto" ? "auto" : { provider: argv.secondOpinion };
     }
     if (argv.context) {
         correction.context = argv.context;
@@ -177,8 +178,19 @@ function buildCommonOptions(argv, dictionary) {
         ...(correction ? { correction } : {}),
         ...(argv.fallback ? { fallback: { provider: argv.fallback } } : {}),
         ...(argv.timeout !== undefined ? { timeoutMs: argv.timeout } : {}),
+        ...(outputLanguagesArg(argv.to)
+            ? { output: { languages: outputLanguagesArg(argv.to) ?? [] } }
+            : {}),
     };
 }
+/** `--to es,hi-Latn` (or the flag repeated) → the tags, or `undefined` when none. */
+function outputLanguagesArg(value) {
+    const tags = (Array.isArray(value) ? value : value ? [value] : [])
+        .flatMap((v) => v.split(","))
+        .map((t) => t.trim())
+        .filter(Boolean);
+    return tags.length ? tags : undefined;
+}
 // ---------------------------------------------------------------------------
 // Decoding for --stream
 // ---------------------------------------------------------------------------
@@ -332,6 +344,7 @@ function trailLine(result) {
         ["second opinion", t.secondOpinionMs],
         ["decide", t.decideMs],
         ["rewrite", t.rewriteMs],
+        ["outputs", t.outputMs],
         ["total", t.totalMs],
     ]
         .filter((entry) => typeof entry[1] === "number")
@@ -470,6 +483,12 @@ function createCliTranscribeStreamSink(argv) {
                         process.stdout.write(chalk.gray(`[utterance ${event.utterance}: ${event.seconds.toFixed(1)}s no engine could read]\n`));
                     }
                     break;
+                case "output":
+                    clearLive();
+                    process.stdout.write(event.text
+                        ? `${chalk.magenta(`  ${event.language}:`)} ${event.text}\n`
+                        : chalk.gray(`  ${event.language}: ${event.status}${event.reason ? ` (${event.reason})` : ""}\n`));
+                    break;
                 case "error":
                     clearLive();
                     logger.error(chalk.red(`Error${event.utterance !== undefined ? ` (utterance ${event.utterance})` : ""}: ${event.message}`));
@@ -559,7 +578,11 @@ export const transcribeCommand = {
     })
         .option("second-opinion", {
         type: "string",
-        describe: "Second STT provider run on the same audio; the rewrite reconciles both",
+        describe: 'Second STT provider run on the same audio; the rewrite reconciles both ("auto": the --fallback engine)',
+    })
+        .option("to", {
+        type: "string",
+        describe: "Output languages, comma-separated BCP-47 tags: es, fr-CA, hi-Latn (romanized Hindi), source",
     })
         .option("fallback", {
         type: "string",
@@ -572,6 +595,11 @@ export const transcribeCommand = {
         .option("stream", {
         type: "boolean",
         describe: "Stream the file through transcribeStream (decoded to 16 kHz PCM16) and print live text",
+    })
+        .option("vad", {
+        type: "string",
+        choices: ["auto", "silero", "energy"],
+        describe: "With --stream: the speech detector that finds utterances (default auto: Silero when it loads, else the energy gate)",
     })
         .option("format", {
         type: "string",
@@ -649,7 +677,10 @@ export const transcribeCommand = {
                 const events = neurolink.transcribeStream({
                     ...options,
                     audio: pcmFrames(pcm),
-                    streaming: { sampleRate: TARGET_SAMPLE_RATE },
+                    streaming: {
+                        sampleRate: TARGET_SAMPLE_RATE,
+                        ...(argv.vad ? { vad: { engine: argv.vad } } : {}),
+                    },
                 });
                 for await (const event of events) {
                     sink.event(event);
@@ -701,6 +732,11 @@ export const transcribeCommand = {
             return;
         }
         logger.always(result.text);
+        for (const rendering of Object.values(result.outputs ?? {})) {
+            logger.always(rendering.text
+                ? `${chalk.magenta(`${rendering.language}:`)} ${rendering.text}`
+                : chalk.gray(`${rendering.language}: ${rendering.status}${rendering.reason ? ` (${rendering.reason})` : ""}`));
+        }
         if (!argv.quiet) {
             logger.always(chalk.gray(trailLine(result)));
         }

package/dist/constants/langfuse.d.ts

@@ -21,6 +21,8 @@ export declare const MAX_CONCURRENT_DELIVERIES = 4;
 export declare const MAX_QUEUED_SPANS = 10000;
 /** @description Milliseconds between warn-level logs about waiting spans dropped for lack of a delivery slot. */
 export declare const QUEUE_DROP_WARN_INTERVAL_MS = 60000;
+/** @description Milliseconds between error-level logs about spans dropped because Langfuse rejected the credentials. */
+export declare const CREDENTIALS_WARN_INTERVAL_MS = 60000;
 /** @description Longest `Retry-After` a 429 or 503 from Langfuse is waited out before the retry. */
 export declare const MAX_EXPORT_RETRY_AFTER_MS = 60000;
 /** @description Maximum serialized bytes sent in one export request. */

package/dist/constants/langfuse.js

@@ -21,6 +21,8 @@ export const MAX_CONCURRENT_DELIVERIES = 4;
 export const MAX_QUEUED_SPANS = 10_000;
 /** @description Milliseconds between warn-level logs about waiting spans dropped for lack of a delivery slot. */
 export const QUEUE_DROP_WARN_INTERVAL_MS = 60_000;
+/** @description Milliseconds between error-level logs about spans dropped because Langfuse rejected the credentials. */
+export const CREDENTIALS_WARN_INTERVAL_MS = 60_000;
 /** @description Longest `Retry-After` a 429 or 503 from Langfuse is waited out before the retry. */
 export const MAX_EXPORT_RETRY_AFTER_MS = 60_000;
 /** @description Maximum serialized bytes sent in one export request. */

package/dist/factories/sttDescriptors.js

@@ -246,6 +246,13 @@ function validateSTTEndpoints(source, entries) {
             ...(typeof c.apiKey === "string" ? { apiKey: c.apiKey } : {}),
             ...(typeof c.model === "string" ? { model: c.model } : {}),
             ...(typeof c.timeoutMs === "number" ? { timeoutMs: c.timeoutMs } : {}),
+            ...(typeof c.priorLanguageForm === "string"
+                ? { priorLanguageForm: c.priorLanguageForm }
+                : {}),
+            ...(typeof c.lidModel === "string" ? { lidModel: c.lidModel } : {}),
+            ...(typeof c.vocabularyPrompt === "boolean"
+                ? { vocabularyPrompt: c.vocabularyPrompt }
+                : {}),
         };
     }
     return out;

package/dist/index.d.ts

@@ -73,6 +73,7 @@ export { STTProcessor } from "./utils/sttProcessor.js";
 export { describeSTTProviderKeys, isSTTProviderConfigured, resolveDefaultSTTProvider, STT_PROVIDER_DESCRIPTORS, } from "./factories/sttDescriptors.js";
 export { buildSpeakerTurns, listSpeakers } from "./utils/speakerTurns.js";
 export { correctTranscript } from "./voice/correction/index.js";
+export { TranscriptionSession } from "./voice/session/transcriptionSession.js";
 export { AzureTTS, AzureTTSHandler, CartesiaTTS, CartesiaTTSHandler, ElevenLabsTTS, ElevenLabsTTSHandler, FishAudioTTS, FishAudioTTSHandler, SixtyDBTTS, SixtyDBTTSHandler, GoogleTTSHandler, OpenAITTS, OpenAITTSHandler, AzureSTT, AzureSTTHandler, DeepgramSTT, DeepgramSTTHandler, ElevenLabsSTT, ElevenLabsSTTHandler, GoogleSTT, GoogleSTTHandler, OpenAISTT, OpenAISTTHandler, WhisperSTT, WhisperSTTHandler, WhistleSTT, WhistleSTTHandler, BaseRealtimeHandler, GeminiLive, GeminiLiveHandler, OpenAIRealtime, OpenAIRealtimeHandler, RealtimeProcessor, RealtimeError, STTError, VoiceError, registerDefaultRealtimeHandlers, registerDefaultSTTHandlers, registerDefaultTTSHandlers, } from "./voice/index.js";
 export { BeatovenMusic, BeatovenMusicHandler, ElevenLabsMusic, ElevenLabsMusicHandler, LyriaMusic, LyriaMusicHandler, registerDefaultMusicHandlers, ReplicateMusic, ReplicateMusicHandler, } from "./music/index.js";
 export { DIDAvatar, DIDAvatarHandler, HeyGenAvatar, HeyGenAvatarHandler, registerDefaultAvatarHandlers, ReplicateAvatar, ReplicateAvatarHandler, } from "./avatar/index.js";
@@ -84,8 +85,8 @@ export { HITLManager } from "./hitl/hitlManager.js";
 export { ProviderRegistry } from "./factories/providerRegistry.js";
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
-import { flushOpenTelemetry, getLangfuseHealthStatus, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry } from "./services/server/ai/observability/instrumentation.js";
-export { shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, isOpenTelemetryInitialized, };
+import { ensureTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry } from "./services/server/ai/observability/instrumentation.js";
+export { ensureTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, isOpenTelemetryInitialized, };
 export { clearAnalyticsMetrics, createAnalyticsMiddleware, getAnalyticsMetrics, } from "./middleware/builtin/analytics.js";
 export { createLifecycleMiddleware } from "./middleware/builtin/lifecycle.js";
 export { MiddlewareFactory } from "./middleware/factory.js";

package/dist/index.js

@@ -126,6 +126,8 @@ export { STTProcessor } from "./utils/sttProcessor.js";
 export { describeSTTProviderKeys, isSTTProviderConfigured, resolveDefaultSTTProvider, STT_PROVIDER_DESCRIPTORS, } from "./factories/sttDescriptors.js";
 export { buildSpeakerTurns, listSpeakers } from "./utils/speakerTurns.js";
 export { correctTranscript } from "./voice/correction/index.js";
+// Transcription sessions: several speakers, listeners in their own languages.
+export { TranscriptionSession } from "./voice/session/transcriptionSession.js";
 // STT_ERROR_CODES is surfaced via the types barrel (export * from "./types/index.js")
 // STTError is re-exported below from the voice/index.js barrel
 // ============================================================================
@@ -172,8 +174,8 @@ export { ProviderRegistry } from "./factories/providerRegistry.js";
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 // Observability configuration types
-import { flushOpenTelemetry, getLangfuseHealthStatus, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
-export { shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, isOpenTelemetryInitialized, };
+import { ensureTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
+export { ensureTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, isOpenTelemetryInitialized, };
 // Analytics Middleware exports
 export { clearAnalyticsMetrics, createAnalyticsMiddleware, getAnalyticsMetrics, } from "./middleware/builtin/analytics.js";
 export { createLifecycleMiddleware } from "./middleware/builtin/lifecycle.js";

package/dist/mcp/externalServerManager.js

@@ -8,7 +8,7 @@
  */
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
-import { MCPClientFactory } from "./mcpClientFactory.js";
+import { MCPClientFactory, terminateStartingStdioServers, } from "./mcpClientFactory.js";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
 import { toolRegistry } from "./toolRegistry.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
@@ -372,6 +372,9 @@ const shutdownOnSignal = (signal) => {
         // re-raise and nowhere else.
         if (!hadOtherListeners) {
             process.removeListener(signal, shutdownOnSignal);
+            // Dying of a signal runs no `exit` handler, and the cleanup above cannot
+            // reach a server whose handshake is still pending.
+            terminateStartingStdioServers();
             process.kill(process.pid, signal);
         }
     });

package/dist/mcp/mcpClientFactory.d.ts

@@ -9,6 +9,12 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
 import type { ChildProcess } from "child_process";
 import type { MCPTransportType, MCPServerInfo, MCPClientResult } from "../types/index.js";
+/**
+ * Synchronous on purpose: it is the one thing that can run inside the
+ * `exit` event, and SIGTERM is delivered by the kernel even though this
+ * process is already on its way out.
+ */
+export declare const terminateStartingStdioServers: () => void;
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports

package/dist/mcp/mcpClientFactory.js

@@ -62,6 +62,48 @@ class StderrTail {
     }
 }
 const stderrTails = new WeakMap();
+/**
+ * Stdio servers that have been spawned but have not yet answered `initialize`.
+ *
+ * Nothing that cleans up at exit can reach one: the manager learns of a client
+ * and its transport only when `connect()` returns, and `process.exit()` runs
+ * no async handler anyway. It is also the state a server is least likely to
+ * notice its host going away, because `npx -y <pkg>` does not read its stdin
+ * until the package has downloaded. Once a server has answered it is an
+ * ordinary MCP server again and ends when its stdin closes, so it leaves this
+ * set and the shutdown paths that already exist keep ownership of it.
+ */
+const startingStdioTransports = new Set();
+let startingStdioExitHookInstalled = false;
+/**
+ * Synchronous on purpose: it is the one thing that can run inside the
+ * `exit` event, and SIGTERM is delivered by the kernel even though this
+ * process is already on its way out.
+ */
+export const terminateStartingStdioServers = () => {
+    for (const transport of startingStdioTransports) {
+        if ("pid" in transport && typeof transport.pid === "number") {
+            try {
+                process.kill(transport.pid, "SIGTERM");
+            }
+            catch {
+                // Already gone.
+            }
+        }
+    }
+};
+const trackStartingStdioTransport = (transport) => {
+    if (!startingStdioExitHookInstalled) {
+        startingStdioExitHookInstalled = true;
+        process.on("exit", terminateStartingStdioServers);
+    }
+    startingStdioTransports.add(transport);
+    // Client.connect() chains an onclose that is already set rather than
+    // replacing it, and a spawn that fails still closes the transport.
+    transport.onclose = () => {
+        startingStdioTransports.delete(transport);
+    };
+};
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -223,6 +265,7 @@ export class MCPClientFactory {
             }
             // Connect with timeout
             await this.raceWithTimeout(client.connect(transport, { timeout }), timeout, `Client connection timeout for ${config.id}`);
+            startingStdioTransports.delete(transport);
             // Perform handshake to get server capabilities
             const serverCapabilities = await this.performHandshake(client, timeout);
             mcpLogger.debug(`[MCPClientFactory] Handshake completed for ${config.id}`, {
@@ -318,6 +361,7 @@ export class MCPClientFactory {
             cwd: config.cwd,
             stderr: "pipe",
         });
+        trackStartingStdioTransport(transport);
         const tail = new StderrTail();
         stderrTails.set(transport, tail);
         transport.stderr?.on("data", (chunk) => {

package/dist/neurolink.js

@@ -3209,7 +3209,9 @@ Current user's request: ${currentInput}`;
             langfuse: langfuseConfig !== undefined || hasProcessor
                 ? {
                     enabled: hasProcessor,
-                    baseUrl: langfuseOptions?.baseUrl ?? process.env.LANGFUSE_BASE_URL,
+                    baseUrl: langfuseOptions?.baseUrl ||
+                        process.env.LANGFUSE_BASE_URL ||
+                        undefined,
                     environment: langfuseOptions?.environment ??
                         process.env.LANGFUSE_TRACING_ENVIRONMENT,
                 }
@@ -8991,8 +8993,6 @@ Current user's request: ${currentInput}`;
     async prepareStreamOptions(options, streamId, startTime, hrTimeStart) {
         // Initialize conversation memory if needed (for lazy loading)
         await this.initializeConversationMemoryForGeneration(streamId, startTime, hrTimeStart);
-        // Initialize MCP
-        await this.initializeMCP();
         // Memory retrieval
         if (this.shouldReadMemory(options.memory, options.context?.userId) &&
             options.context?.userId) {
@@ -9040,6 +9040,15 @@ Current user's request: ${currentInput}`;
         }
         // Auto-disable tools for Ollama models that don't support them
         await this.autoDisableOllamaStreamTools(options);
+        // generate() skips MCP when tools are disabled, so stream() must too:
+        // initialization loads the working directory's .mcp-config.json and waits
+        // for every stdio server it names before the request is sent, so an
+        // `npx -y …` entry on a slow npm registry stalls a stream that never
+        // needed a tool. Decided after the Ollama check above, which can turn
+        // tools off. Providers register themselves in AIProviderFactory.
+        if (!options.disableTools) {
+            await this.initializeMCP();
+        }
         // RAG Integration: If rag config is provided, prepare the RAG search tool
         if (options.rag?.files?.length) {
             try {
@@ -14710,6 +14719,36 @@ Current user's request: ${currentInput}`;
                     clearTimeout(timer);
                 }
             },
+            render: async (o) => {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), o.timeoutMs);
+                // Output rendering is translation, often worth a stronger model than
+                // the rewrite; it has its own setting and falls back to the rewrite's.
+                const provider = o.provider ??
+                    (process.env.NEUROLINK_STT_OUTPUT_PROVIDER?.trim() ||
+                        process.env.NEUROLINK_STT_REWRITE_PROVIDER?.trim());
+                const model = o.model ??
+                    (process.env.NEUROLINK_STT_OUTPUT_MODEL?.trim() ||
+                        process.env.NEUROLINK_STT_REWRITE_MODEL?.trim());
+                try {
+                    const generated = await this.generate({
+                        input: { text: o.user },
+                        systemPrompt: o.system,
+                        schema: o.schema,
+                        ...(provider ? { provider } : {}),
+                        ...(model ? { model } : {}),
+                        maxTokens: o.maxTokens,
+                        temperature: 0,
+                        disableTools: true,
+                        memory: { enabled: false },
+                        abortSignal: controller.signal,
+                    });
+                    return generated.structuredData ?? generated.content ?? "";
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            },
         };
     }
     /**

package/dist/observability/exporters/langfuseExporter.d.ts

@@ -16,6 +16,9 @@ export declare class LangfuseExporter extends BaseExporter {
     private lastDeliveryError;
     private unwarnedQueueDrops;
     private lastQueueDropWarning;
+    private unwarnedRefusals;
+    private lastRefusalWarning;
+    private credentialsRejected;
     /**
      * @description Creates an exporter for one Langfuse project.
      * @param config {LangfuseExporterConfig} - Credentials, endpoint, environment, release, masking, batching and flush-budget options. `environment` and `release` fall back to `LANGFUSE_TRACING_ENVIRONMENT` and `LANGFUSE_RELEASE`, and only fill spans that do not carry them already.
@@ -47,6 +50,7 @@ export declare class LangfuseExporter extends BaseExporter {
     getStatus(): ExporterStatus;
     healthCheck(): Promise<ExporterHealthStatus>;
     protected ping(): Promise<void>;
+    private reportRefusals;
     private record;
     private deliver;
     private post;

package/dist/observability/exporters/langfuseExporter.js

@@ -1,9 +1,8 @@
-import { DEFAULT_BASE_URL, DEFAULT_FLUSH_AT, DEFAULT_FLUSH_BUDGET_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_TIMEOUT_MS, HEALTH_PATH, MAX_CONCURRENT_DELIVERIES, MAX_EXPORT_RETRY_AFTER_MS, MAX_QUEUED_SPANS, MAX_SPANS_PER_REQUEST, QUEUE_DROP_WARN_INTERVAL_MS, TRACES_PATH, } from "../../constants/langfuse.js";
+import { CREDENTIALS_WARN_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_FLUSH_AT, DEFAULT_FLUSH_BUDGET_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_TIMEOUT_MS, HEALTH_PATH, MAX_CONCURRENT_DELIVERIES, MAX_EXPORT_RETRY_AFTER_MS, MAX_QUEUED_SPANS, MAX_SPANS_PER_REQUEST, QUEUE_DROP_WARN_INTERVAL_MS, TRACES_PATH, } from "../../constants/langfuse.js";
 import { logger } from "../../utils/logger.js";
 import { parseRetryAfterMs } from "../../utils/retryAfter.js";
 import { chunkOtlpSpans, toOtlpEncodedSpan, toOtlpRequest, } from "../otlpEncoding.js";
 import { BaseExporter, exponentialRetryDelayMs, exporterStatusOf, reportDeliveriesWith, } from "./baseExporter.js";
-let credentialsWarned = false;
 let malformedRejectionLogged = false;
 function isRetryable(status) {
     return status === 429 || status >= 500;
@@ -73,6 +72,9 @@ export class LangfuseExporter extends BaseExporter {
     lastDeliveryError;
     unwarnedQueueDrops = 0;
     lastQueueDropWarning = 0;
+    unwarnedRefusals = 0;
+    lastRefusalWarning = 0;
+    credentialsRejected = false;
     /**
      * @description Creates an exporter for one Langfuse project.
      * @param config {LangfuseExporterConfig} - Credentials, endpoint, environment, release, masking, batching and flush-budget options. `environment` and `release` fall back to `LANGFUSE_TRACING_ENVIRONMENT` and `LANGFUSE_RELEASE`, and only fill spans that do not carry them already.
@@ -84,7 +86,7 @@ export class LangfuseExporter extends BaseExporter {
         });
         this.langfuse = langfuse;
         this.authorization = `Basic ${Buffer.from(`${langfuse.publicKey}:${langfuse.secretKey}`).toString("base64")}`;
-        this.baseUrl = (langfuse.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.baseUrl = (langfuse.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
         this.flushBudgetMs =
             langfuse.flushBudgetMs !== undefined && langfuse.flushBudgetMs > 0
                 ? langfuse.flushBudgetMs
@@ -218,6 +220,9 @@ export class LangfuseExporter extends BaseExporter {
             this.lastDeliveryError = "Langfuse exporter shut down before delivery";
             logger.warn(`[langfuse] Dropped ${stranded} spans still waiting at shutdown`);
         }
+        if (this.unwarnedRefusals > 0) {
+            this.reportRefusals();
+        }
     }
     /**
      * @description Snapshot of this exporter for status reporting, without a network call: what is queued, what Langfuse accepted and what was dropped, and unhealthy while the latest delivery failed.
@@ -257,6 +262,10 @@ export class LangfuseExporter extends BaseExporter {
             throw new Error(`Langfuse API unreachable: ${response.status}`);
         }
     }
+    reportRefusals() {
+        logger.error(`[langfuse] Langfuse credentials rejected; dropped ${this.unwarnedRefusals} spans`);
+        this.unwarnedRefusals = 0;
+    }
     record(total, report, durationMs) {
         if (total === 0) {
             return this.createSuccessResult(0, durationMs);
@@ -269,7 +278,7 @@ export class LangfuseExporter extends BaseExporter {
             report.delivered === 0 && failed > 0
                 ? `Dropped ${failed} of ${total} spans: ${report.error ?? "Langfuse rejected every span"}`
                 : report.error;
-        if (failed > 0) {
+        if (failed > report.refused) {
             logger.warn(`[langfuse] Dropped ${failed} of ${total} spans`, {
                 error: report.error,
             });
@@ -296,6 +305,7 @@ export class LangfuseExporter extends BaseExporter {
         const report = {
             delivered: 0,
             rejected: 0,
+            refused: 0,
             droppedIds: [],
         };
         for (const chunk of chunkOtlpSpans(items)) {
@@ -308,6 +318,9 @@ export class LangfuseExporter extends BaseExporter {
                 else {
                     report.droppedIds.push(...chunk.map(({ span }) => span.spanId));
                     report.error = "Langfuse did not accept the batch";
+                    if (outcome.refused) {
+                        report.refused += chunk.length;
+                    }
                 }
             }
             catch (error) {
@@ -334,11 +347,14 @@ export class LangfuseExporter extends BaseExporter {
             ]),
         });
         if (response.status === 401 || response.status === 403) {
-            if (!credentialsWarned) {
-                credentialsWarned = true;
-                logger.warn("[langfuse] Langfuse credentials rejected");
+            this.credentialsRejected = true;
+            this.unwarnedRefusals += chunk.length;
+            const now = Date.now();
+            if (now - this.lastRefusalWarning >= CREDENTIALS_WARN_INTERVAL_MS) {
+                this.reportRefusals();
+                this.lastRefusalWarning = now;
             }
-            return { accepted: false };
+            return { accepted: false, refused: true };
         }
         if (isRetryable(response.status)) {
             const retryAfterMs = response.status === 429 || response.status === 503
@@ -350,6 +366,11 @@ export class LangfuseExporter extends BaseExporter {
             logger.warn(`[langfuse] Export rejected with ${response.status}`);
             return { accepted: false };
         }
+        if (this.credentialsRejected) {
+            logger.error(`[langfuse] Langfuse credentials accepted again; dropped ${this.unwarnedRefusals} spans since the last warning`);
+            this.credentialsRejected = false;
+            this.unwarnedRefusals = 0;
+        }
         // Langfuse took the request; a body that is not an object, or not JSON,
         // reports no rejections.
         const partial = partialSuccessOf(await response.json().catch(() => undefined));

package/dist/observability/otlpEncoding.js

@@ -13,8 +13,8 @@ function toOtlpValue(value) {
         return { boolValue: value };
     }
     if (typeof value === "number") {
-        return Number.isInteger(value)
-            ? { intValue: String(value) }
+        return Number.isSafeInteger(value)
+            ? { intValue: value }
             : { doubleValue: value };
     }
     if (Array.isArray(value)) {

package/dist/server/abstract/baseServerAdapter.js

@@ -86,6 +86,8 @@ export class BaseServerAdapter extends EventEmitter {
                 enabled: config.bodyParser?.enabled ?? true,
                 maxSize: config.bodyParser?.maxSize ?? "10mb",
                 jsonLimit: config.bodyParser?.jsonLimit ?? "10mb",
+                // An operator's explicit maxSize also caps raw uploads.
+                rawMaxSize: config.bodyParser?.rawMaxSize ?? config.bodyParser?.maxSize ?? "64mb",
                 urlEncoded: config.bodyParser?.urlEncoded ?? true,
             },
             logging: {

package/dist/server/adapters/expressAdapter.js

@@ -46,7 +46,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
             // Uploads (multipart, octet-stream, audio/*) reach the route as bytes.
             this.app.use(express.raw({
                 type: (req) => isRawBodyContentType(req.headers["content-type"]),
-                limit: this.config.bodyParser.maxSize || "10mb",
+                limit: this.config.bodyParser.rawMaxSize || "64mb",
             }));
         }
         // CORS

package/dist/server/adapters/fastifyAdapter.js

@@ -50,7 +50,10 @@ export class FastifyServerAdapter extends BaseServerAdapter {
         // Uploads (multipart, octet-stream, audio/*) reach the route as bytes;
         // without a parser Fastify refuses these content types with a 415.
         if (this.config.bodyParser.enabled) {
-            this.app.addContentTypeParser(/^\s*(multipart\/form-data|application\/octet-stream|audio\/)/i, { parseAs: "buffer" }, (request, body, done) => {
+            this.app.addContentTypeParser(/^\s*(multipart\/form-data|application\/octet-stream|audio\/)/i, {
+                parseAs: "buffer",
+                bodyLimit: this.parseBodyLimit(this.config.bodyParser.rawMaxSize),
+            }, (request, body, done) => {
                 done(null, isRawBodyContentType(request.headers["content-type"])
                     ? body
                     : undefined);

package/dist/server/adapters/honoAdapter.js

@@ -693,7 +693,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
         // a throw from the middleware path would land in onError, which answers
         // 500. The route answers 413 (or a validation error) from it.
         if (isRawBodyContentType(contentType)) {
-            const limit = parseByteLimit(this.config.bodyParser.maxSize);
+            const limit = parseByteLimit(this.config.bodyParser.rawMaxSize);
             if (Number(c.req.header("Content-Length") ?? 0) > limit) {
                 return new RawBodyTooLargeError(limit);
             }

package/dist/server/adapters/koaAdapter.js

@@ -113,7 +113,7 @@ export class KoaServerAdapter extends BaseServerAdapter {
                 enableTypes: ["json", "form", "text"],
             }));
             // Uploads (multipart, octet-stream, audio/*) reach the route as bytes.
-            const rawLimit = parseByteLimit(this.config.bodyParser.maxSize);
+            const rawLimit = parseByteLimit(this.config.bodyParser.rawMaxSize);
             this.app.use(async (ctx, next) => {
                 if (isRawBodyContentType(ctx.get("content-type"))) {
                     try {

package/dist/server/routes/transcribeRoutes.d.ts

@@ -12,12 +12,4 @@
  * the server's own configuration.
  */
 import type { RouteGroup, ServerTranscribeRouteOptions } from "../../types/index.js";
-/**
- * Create the transcription routes.
- *
- * @param basePath - Prefix of the NeuroLink route (default `/api`).
- * @param options - `allowedAudioRoots` (default: `audioPath` refused),
- *   `maxAudioBytes` (default 50 MB) and `openaiBasePath` (default `""`, so the
- *   OpenAI-compatible route is `/v1/audio/transcriptions`).
- */
 export declare function createTranscribeRoutes(basePath?: string, options?: ServerTranscribeRouteOptions): RouteGroup;