@juspay/neurolink 12.14.0 → 12.14.2

package/dist/cli/commands/proxy.d.ts

@@ -88,5 +88,6 @@ export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;
 export declare const proxyTelemetryCommand: CommandModule<object, ProxyTelemetryArgs>;
 export declare const proxyGuardCommand: CommandModule<object, ProxyGuardArgs>;
 export declare const proxySetupCommand: CommandModule;
+export declare function buildProxyLaunchdPlist(port: number, host: string, envFile?: string, configFile?: string): string;
 export declare const proxyInstallCommand: CommandModule;
 export declare const proxyUninstallCommand: CommandModule;

package/dist/cli/commands/proxy.js

@@ -1,14 +1,5 @@
-/**
- * Proxy CLI Commands for NeuroLink
- *
- * Implements commands for managing the Claude multi-account proxy:
- * - neurolink proxy start  — Start the proxy server
- * - neurolink proxy status — Show proxy status (accounts, sessions, routing)
- *
- * The proxy creates a NeuroLink instance and builds a Hono app that registers
- * Claude-compatible proxy routes. All requests flow through ctx.neurolink
- * (generate/stream), with an optional ModelRouter for model remapping.
- */
+import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -2398,6 +2389,8 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
+            await flushProxyOtelLogs();
+            await shutdownProxyOtelLogs();
             await flushOpenTelemetry();
             await shutdownOpenTelemetry();
         }
@@ -2758,6 +2751,9 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    await loadProxyStartEnv(argv, spinner);
+    initializeProxyOtelLogs("supervisor");
+    routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
     const entryScript = process.argv[1];
     if (!entryScript) {
@@ -2871,6 +2867,8 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         updaterSupervisor.stop();
         await rollingServer.close();
         await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
+        await flushProxyOtelLogs().catch(() => undefined);
+        await shutdownProxyOtelLogs().catch(() => undefined);
         const supervisorState = loadProxySupervisorState();
         if (supervisorState?.pid === process.pid) {
             clearProxySupervisorState();
@@ -2951,6 +2949,8 @@ async function startProxyCommandHandler(argv) {
             env: baseEnv,
         });
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
+        initializeProxyOtelLogs("worker");
+        routeProxyConsoleToOtel();
         // Reuse upstream TCP connections (longer keep-alive + bounded pool) instead
         // of opening a new flow per request — cuts outbound flow churn through host
         // content-filters. Runs once, after env load so it can be tuned via env.
@@ -3592,7 +3592,9 @@ export const proxyGuardCommand = {
             default: true,
         });
     },
-    handler: async (argv) => {
+    handler: withProxyOtelLogShutdown(async (argv) => {
+        initializeProxyOtelLogs("updater");
+        routeProxyConsoleToOtel();
         const host = argv.host ?? "127.0.0.1";
         const port = argv.port ?? 55669;
         const parentPid = Number(argv.parentPid);
@@ -3916,6 +3918,8 @@ export const proxyGuardCommand = {
                     logger.always(`[updater] update successful: now running ${result.latestVersion}`);
                     persistUpdaterState("record successful update", () => recordSuccessfulUpdate(result.latestVersion));
                     // The replacement proxy starts a worker running the new version.
+                    await flushProxyOtelLogs().catch(() => undefined);
+                    await shutdownProxyOtelLogs().catch(() => undefined);
                     process.exit(0);
                 }
                 else {
@@ -4083,7 +4087,7 @@ export const proxyGuardCommand = {
         if (cleared && !argv.quiet) {
             logger.always(`[proxy] fail-open guard removed stale ${expectedBaseUrl} from Claude settings`);
         }
-    },
+    }),
 };
 // =============================================================================
 // PROXY SETUP COMMAND
@@ -4257,7 +4261,7 @@ function buildLaunchdPath() {
     }
     return [...segments].join(":");
 }
-function buildPlist(port, host, envFile, configFile) {
+export function buildProxyLaunchdPlist(port, host, envFile, configFile) {
     // The plist invokes the trampoline script (a tiny shell wrapper at
     // ~/.neurolink/bin/neurolink-proxy) which re-resolves the real
     // `neurolink` binary via PATH on every launch.  This way, launchd
@@ -4273,6 +4277,20 @@ function buildPlist(port, host, envFile, configFile) {
     <string>--config</string>
     <string>${escapeXml(configFile)}</string>`
         : "";
+    const otelEnvironment = isProxyOtelOnly()
+        ? [
+            "NEUROLINK_PROXY_LOG_SINK",
+            "OTEL_EXPORTER_OTLP_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_HEADERS",
+            "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+            "OTEL_SERVICE_NAME",
+            "NEUROLINK_PROXY_SESSION_SECRET",
+        ]
+            .filter((name) => process.env[name] !== undefined)
+            .map((name) => `    <key>${name}</key>\n    <string>${escapeXml(process.env[name])}</string>`)
+            .join("\n")
+        : "";
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
   "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -4311,10 +4329,10 @@ ${configArgs}
   <integer>45</integer>
 
   <key>StandardOutPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
 
   <key>EnvironmentVariables</key>
   <dict>
@@ -4322,6 +4340,7 @@ ${configArgs}
     <string>${buildLaunchdPath()}</string>
     <key>HOME</key>
     <string>${homedir()}</string>
+${otelEnvironment}
   </dict>
 </dict>
 </plist>`;
@@ -4362,7 +4381,7 @@ export const proxyInstallCommand = {
             console.info(chalk.yellow("On Linux, use systemd. On Windows, use Task Scheduler."));
             process.exit(1);
         }
-        const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+        const { mkdirSync, existsSync, chmodSync } = await import("fs");
         const envResolution = resolveProxyEnvFile({
             explicitEnvFile: argv.envFile,
         });
@@ -4378,8 +4397,9 @@ export const proxyInstallCommand = {
             console.info(chalk.red(`Proxy env file not found: ${envFile}`));
             process.exit(1);
         }
+        await loadProxyEnvFile({ explicitEnvFile: envFile });
         const logsDir = join(homedir(), ".neurolink", "logs");
-        if (!existsSync(logsDir)) {
+        if (!isProxyOtelOnly() && !existsSync(logsDir)) {
             mkdirSync(logsDir, { recursive: true });
         }
         if (!existsSync(PLIST_DIR)) {
@@ -4403,8 +4423,9 @@ export const proxyInstallCommand = {
             process.exit(1);
         }
         console.info(chalk.green(`✓ Trampoline validated (resolves to neurolink v${trampolineVersion})`));
-        const plist = buildPlist(port, host, envFile, configFile);
-        writeFileSync(PLIST_PATH, plist, "utf-8");
+        const plist = buildProxyLaunchdPlist(port, host, envFile, configFile);
+        await writeFileAtomic(PLIST_PATH, plist, 0o600);
+        chmodSync(PLIST_PATH, 0o600);
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));
         if (envFile) {
             console.info(chalk.green(`✓ Proxy env file: ${envFile}`));

package/dist/neurolink.js

@@ -4159,6 +4159,22 @@ Current user's request: ${currentInput}`;
             middleware: options.middleware,
             conversationMessages: options.conversationMessages,
             credentials: options.credentials,
+            // Extended thinking. Every provider gates it on `thinkingConfig`, so
+            // omitting the field here meant it never reached one: the request went
+            // out with no thinking block and the result carried no reasoning, with
+            // nothing raised to say the option had been discarded. This is the same
+            // failure the note above records for `disableInternalFallback` — an
+            // allowlist that silently swallows a documented option.
+            //
+            // `thinkingConfig` is the only one of the documented thinking options
+            // that `GenerateOptions` actually declares. `thinking`, `thinkingBudget`
+            // and `thinkingLevel` are folded into a `thinkingConfig` only by the CLI,
+            // in `src/lib/utils/thinkingConfig.ts`; nothing on the SDK path does that
+            // merge. They exist solely on the internal `TextGenerationOptions`, so no
+            // caller can pass them through
+            // generate() today. Declaring them is a public-type decision and is
+            // deliberately left out of this fix.
+            thinkingConfig: options.thinkingConfig,
             // Lifecycle callbacks must reach the provider so non-AI-SDK paths
             // (Vertex's native @google/genai, native Bedrock, Ollama, etc.) can
             // invoke them directly. Pipeline A also still receives them via the

package/dist/providers/anthropic/client.js

@@ -292,6 +292,12 @@ const messagesToAnthropic = (msgs) => {
             }
             case "assistant": {
                 const blocks = [];
+                // Extended thinking must come back byte-identical — signature
+                // included — or Anthropic rejects the turn, and the loop replays this
+                // message on every tool step. Blocks are emitted in content order
+                // rather than hoisted: `interleaved-thinking-2025-05-14` (requested in
+                // the beta header) lets thinking appear between tool calls, so
+                // reordering would corrupt the chain it validates.
                 for (const part of partsOf(msg.content)) {
                     if (typeof part === "string") {
                         if (part.length > 0) {
@@ -300,6 +306,29 @@ const messagesToAnthropic = (msgs) => {
                         continue;
                     }
                     const p = part;
+                    if (p?.type === "reasoning") {
+                        const meta = p.providerOptions?.anthropic;
+                        const redacted = meta?.redactedData;
+                        if (typeof redacted === "string" && redacted.length > 0) {
+                            blocks.push({ type: "redacted_thinking", data: redacted });
+                            continue;
+                        }
+                        const signature = meta?.signature;
+                        // Both halves required, matching loopAdapter's check on the
+                        // streaming path: Anthropic rejects a thinking block that is
+                        // unsigned, and equally one whose text is empty. Reasoning from a
+                        // provider that never produced a signature (a reasoner model's
+                        // plain text) is not an Anthropic thinking block at all, and an
+                        // empty one carries nothing worth replaying — either way, dropping
+                        // it beats sending a block that will be refused.
+                        if (typeof signature === "string" &&
+                            signature.length > 0 &&
+                            typeof p.text === "string" &&
+                            p.text.length > 0) {
+                            blocks.push({ type: "thinking", thinking: p.text, signature });
+                        }
+                        continue;
+                    }
                     if (p?.type === "text" && typeof p.text === "string") {
                         if (p.text.length > 0) {
                             const cc = cacheControlOf(p);
@@ -1118,15 +1147,28 @@ export class AnthropicProvider extends BaseProvider {
                         ? { topP: options.topP }
                         : {}),
                 }, "anthropic.doGenerate");
+                // Dropping a caller's explicit sampling parameters is exactly the
+                // kind of silent discard this change fixes elsewhere, so say so.
+                if (thinking &&
+                    (samplingParams.temperature !== undefined ||
+                        samplingParams.topP !== undefined)) {
+                    logger.debug("[anthropic] extended thinking is enabled, so temperature/top_p are omitted — Anthropic rejects any temperature but 1 while thinking is set");
+                }
                 const params = {
                     model: modelId,
                     messages: cachedMessages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
-                    ...(samplingParams.temperature !== undefined
+                    // Extended thinking fixes sampling: Anthropic rejects any
+                    // temperature but 1 while `thinking` is set, and does not honour
+                    // top_p there. The CLI always sends a default temperature, so
+                    // forwarding it alongside thinking turns a call that used to work
+                    // into a 400. Drop the sampling knobs for exactly those turns and
+                    // let Anthropic's thinking defaults stand.
+                    ...(!thinking && samplingParams.temperature !== undefined
                         ? { temperature: samplingParams.temperature }
                         : {}),
-                    ...(samplingParams.topP !== undefined
+                    ...(!thinking && samplingParams.topP !== undefined
                         ? { top_p: samplingParams.topP }
                         : {}),
                     ...(options.stopSequences && options.stopSequences.length > 0
@@ -1187,7 +1229,29 @@ export class AnthropicProvider extends BaseProvider {
                 let jsonToolAnswered = false;
                 for (const block of response.content) {
                     if (block.type === "thinking") {
-                        content.push({ type: "reasoning", text: block.thinking });
+                        // The signature rides along in providerOptions because Anthropic
+                        // rejects a replayed thinking block without it, and the tool loop
+                        // pushes this part straight back into the conversation.
+                        content.push({
+                            type: "reasoning",
+                            text: block.thinking,
+                            providerOptions: {
+                                anthropic: { signature: block.signature },
+                            },
+                        });
+                    }
+                    else if (block.type === "redacted_thinking") {
+                        // Encrypted reasoning: no readable text, but it must still be
+                        // replayed verbatim or the turn is rejected.
+                        content.push({
+                            type: "reasoning",
+                            text: "",
+                            providerOptions: {
+                                anthropic: {
+                                    redactedData: block.data,
+                                },
+                            },
+                        });
                     }
                     else if (block.type === "text") {
                         // In forced-json mode the payload arrives via the tool input, not
@@ -1824,6 +1888,9 @@ export class AnthropicProvider extends BaseProvider {
                 const streamSamplingParams = resolveSamplingParams("anthropic", modelId, options.temperature !== undefined && options.temperature !== null
                     ? { temperature: options.temperature }
                     : {}, "anthropic.executeStream");
+                if (thinking && streamSamplingParams.temperature !== undefined) {
+                    logger.debug("[anthropic] extended thinking is enabled, so temperature is omitted on the stream path — Anthropic rejects any temperature but 1 while thinking is set");
+                }
                 return {
                     model: modelId,
                     messages: cachedConversation,
@@ -1833,7 +1900,9 @@ export class AnthropicProvider extends BaseProvider {
                     // the adapter immediately overwrites — and forced this whole params
                     // object into the streaming variant for a field it does not own.
                     ...(payload.system ? { system: payload.system } : {}),
-                    ...(streamSamplingParams.temperature !== undefined
+                    // Same constraint on the streaming path: a temperature alongside
+                    // `thinking` is rejected outright.
+                    ...(!thinking && streamSamplingParams.temperature !== undefined
                         ? { temperature: streamSamplingParams.temperature }
                         : {}),
                     ...(cachedTools && cachedTools.length > 0

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -19,4 +19,4 @@ export declare function redactProxyHeadersForLogging(headers: Record<string, str
  * Process a capture in the worker and retain redacted output when artifact
  * persistence fails.
  */
-export declare function processProxyBodyCapture(entry: ProxyBodyCaptureEntry, logDir: string): Promise<ProcessedProxyBodyCapture>;
+export declare function processProxyBodyCapture(entry: ProxyBodyCaptureEntry, logDir: string | null): Promise<ProcessedProxyBodyCapture>;

package/dist/proxy/bodyCaptureProcessing.js

@@ -203,6 +203,16 @@ export function redactProxyHeadersForLogging(headers) {
 export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const prepared = prepareRedactedBody(entry.body);
+    if (logDir === null) {
+        return {
+            headers,
+            stored: {
+                redactedBody: prepared.value,
+                redactedBodyBytes: prepared.bytes,
+                bodyTruncated: prepared.truncated,
+            },
+        };
+    }
     let stored;
     try {
         stored = await writeBodyArtifact(logDir, entry, headers, prepared.value, prepared.truncated);

package/dist/proxy/bodyCaptureWorker.d.ts

@@ -1,7 +1,7 @@
 import type { ProcessedProxyBodyCapture, ProxyBodyCaptureEntry, ProxyBodyCaptureWorkerSnapshot } from "../types/index.js";
 export declare const PROXY_BODY_CAPTURE_DEADLINE_MS = 20000;
 /** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
-export declare function captureProxyBody(entry: ProxyBodyCaptureEntry, logDir: string, consume: (result: ProcessedProxyBodyCapture) => Promise<void>): Promise<void>;
+export declare function captureProxyBody(entry: ProxyBodyCaptureEntry, logDir: string | null, consume: (result: ProcessedProxyBodyCapture) => Promise<void>): Promise<void>;
 /**
  * Return independent counters for processing, rejection, failure, and
  * retained publication work.

package/dist/proxy/logCleanupScheduler.js

@@ -1,3 +1,4 @@
+import { isProxyOtelOnly } from "./otelLogSink.js";
 import { Worker } from "node:worker_threads";
 import { withTimeout } from "../utils/async/withTimeout.js";
 import { logger } from "../utils/logger.js";
@@ -9,6 +10,9 @@ const WORKER_TERMINATION_TIMEOUT_MS = 5_000;
  * block active streams. Concurrent runs are coalesced into the active scan.
  */
 export function startProxyLogCleanupScheduler(params) {
+    if (isProxyOtelOnly()) {
+        return { trigger: () => false, stop: async () => { } };
+    }
     const maxAgeDays = params.maxAgeDays ?? 7;
     const maxSizeMb = params.maxSizeMb ?? 500;
     let activeWorker;

package/dist/proxy/otelLogSink.d.ts

@@ -0,0 +1,34 @@
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+/** Explicit opt-in; configuration never silently falls back to file logging. */
+export declare function isProxyOtelOnly(): boolean;
+/** Initialize a log-only provider in every proxy process, including the supervisor. */
+export declare function initializeProxyOtelLogs(role?: string): LoggerProvider | undefined;
+/** Structured evidence without final-request dashboard fields on auxiliary events. */
+export declare function emitProxyOtelEvent(kind: string, record: Record<string, unknown>): void;
+/** Capture application console diagnostics only inside proxy service processes. */
+export declare function routeProxyConsoleToOtel(): void;
+/** Counters acknowledge collector transport only, never backend persistence. */
+export declare function getProxyOtelLogSnapshot(): {
+    mode: string;
+    initialized: boolean;
+    deliveryGuarantee: string;
+    invalidRecords: number;
+    queues: {
+        attempted: number;
+        submitted: number;
+        transportAcknowledged: number;
+        exportUnconfirmed: number;
+        dropped: number;
+        outstanding: number;
+        lastAcknowledgedAt: string | undefined;
+        lastFailureAt: string | undefined;
+        kind: string;
+        capacity: number;
+    }[];
+};
+/** Bounded provider flush belongs after final request and lifecycle publication. */
+export declare function flushProxyOtelLogs(): Promise<void>;
+/** Release this process's exporter and restore console ownership. */
+export declare function shutdownProxyOtelLogs(): Promise<void>;
+/** Flush short-lived proxy command diagnostics on every normal return or exception. */
+export declare function withProxyOtelLogShutdown<TArg>(handler: (arg: TArg) => Promise<void>): (arg: TArg) => Promise<void>;

package/dist/proxy/otelLogSink.js

@@ -0,0 +1,254 @@
+/* eslint-disable no-console -- This proxy-only sink replaces console methods with OTLP emission. */
+import { inspect } from "node:util";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ExportResultCode } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { sanitizeForLog } from "../utils/logSanitize.js";
+let provider;
+let restoreConsole;
+const queues = [];
+/** Explicit opt-in; configuration never silently falls back to file logging. */
+export function isProxyOtelOnly() {
+    return process.env.NEUROLINK_PROXY_LOG_SINK === "otel";
+}
+/** Reserve capacity including exports in flight, independently for metadata and bodies. */
+function createTrackedProcessor(url, capacity) {
+    const state = {
+        attempted: 0,
+        submitted: 0,
+        transportAcknowledged: 0,
+        exportUnconfirmed: 0,
+        dropped: 0,
+        outstanding: 0,
+        lastAcknowledgedAt: undefined,
+        lastFailureAt: undefined,
+    };
+    const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
+    const exporter = {
+        export(records, callback) {
+            let settled = false;
+            const settle = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                state.outstanding -= records.length;
+                if (result.code === ExportResultCode.SUCCESS) {
+                    state.transportAcknowledged += records.length;
+                    state.lastAcknowledgedAt = new Date().toISOString();
+                }
+                else {
+                    state.exportUnconfirmed += records.length;
+                    state.lastFailureAt = new Date().toISOString();
+                }
+                callback(result);
+            };
+            try {
+                transport.export(records, settle);
+            }
+            catch (error) {
+                settle({
+                    code: ExportResultCode.FAILED,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+            }
+        },
+        shutdown: () => transport.shutdown(),
+    };
+    const batch = new BatchLogRecordProcessor(exporter, {
+        maxQueueSize: capacity,
+        maxExportBatchSize: 64,
+        scheduledDelayMillis: 1000,
+        exportTimeoutMillis: 6000,
+    });
+    const processor = {
+        onEmit(record) {
+            state.attempted++;
+            if (state.outstanding >= capacity) {
+                state.dropped++;
+                return;
+            }
+            state.submitted++;
+            state.outstanding++;
+            batch.onEmit(record);
+        },
+        forceFlush: () => batch.forceFlush(),
+        shutdown: () => batch.shutdown(),
+    };
+    return { state, processor, capacity };
+}
+/** Initialize a log-only provider in every proxy process, including the supervisor. */
+export function initializeProxyOtelLogs(role = "worker") {
+    if (!isProxyOtelOnly()) {
+        return undefined;
+    }
+    if (provider) {
+        return provider;
+    }
+    const endpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT ??
+        (process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+            ? `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT.replace(/\/$/, "")}/v1/logs`
+            : undefined);
+    if (!endpoint) {
+        throw new Error("OTel-only proxy logging requires an OTLP endpoint");
+    }
+    const url = new URL(endpoint);
+    if (!["http:", "https:"].includes(url.protocol)) {
+        throw new Error("Proxy OTLP logs endpoint must use HTTP or HTTPS");
+    }
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol === "http:" && !loopback) {
+        throw new Error("Proxy OTLP logs require HTTPS for non-loopback collectors");
+    }
+    const metadata = createTrackedProcessor(endpoint, 2048);
+    const bodies = createTrackedProcessor(endpoint, 256);
+    queues.push(metadata, bodies);
+    provider = new LoggerProvider({
+        resource: resourceFromAttributes({
+            "service.name": process.env.OTEL_SERVICE_NAME ?? "neurolink-proxy",
+            "service.instance.id": `${role}-${process.pid}`,
+            "process.pid": process.pid,
+            "proxy.process.role": role,
+        }),
+        processors: [
+            {
+                onEmit(record, context) {
+                    (record.attributes?.["proxy.record_kind"] === "body"
+                        ? bodies
+                        : metadata).processor.onEmit(record, context);
+                },
+                forceFlush: async () => {
+                    await Promise.all(queues.map((q) => q.processor.forceFlush()));
+                },
+                shutdown: async () => {
+                    await Promise.all(queues.map((q) => q.processor.shutdown()));
+                },
+            },
+        ],
+    });
+    return provider;
+}
+/** Structured evidence without final-request dashboard fields on auxiliary events. */
+export function emitProxyOtelEvent(kind, record) {
+    if (!isProxyOtelOnly()) {
+        return;
+    }
+    try {
+        initializeProxyOtelLogs()
+            ?.getLogger("neurolink-proxy-events")
+            .emit({
+            severityNumber: SeverityNumber.INFO,
+            severityText: "INFO",
+            body: JSON.stringify(record),
+            attributes: {
+                "proxy.record_kind": kind,
+                "event.name": `proxy.${kind}`,
+                ...(typeof record.requestId === "string"
+                    ? { "request.id": record.requestId }
+                    : {}),
+                ...(typeof record.event === "string"
+                    ? { "proxy.lifecycle.event": record.event }
+                    : {}),
+            },
+        });
+    }
+    catch {
+        // Telemetry must never fail a model request. Invalid records are observable.
+        invalidRecords++;
+    }
+}
+let invalidRecords = 0;
+/** Capture application console diagnostics only inside proxy service processes. */
+export function routeProxyConsoleToOtel() {
+    if (!isProxyOtelOnly() || restoreConsole) {
+        return;
+    }
+    initializeProxyOtelLogs();
+    const originals = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+    };
+    let emitting = false;
+    for (const level of Object.keys(originals)) {
+        console[level] = (...args) => {
+            if (emitting) {
+                return;
+            }
+            emitting = true;
+            try {
+                const body = args
+                    .map((value) => typeof value === "string"
+                    ? value
+                    : inspect(value, {
+                        depth: 4,
+                        maxArrayLength: 30,
+                        maxStringLength: 16000,
+                    }))
+                    .join(" ");
+                provider?.getLogger("neurolink-proxy-console").emit({
+                    body: sanitizeForLog(body, 32000),
+                    severityText: level.toUpperCase(),
+                    severityNumber: level === "error"
+                        ? SeverityNumber.ERROR
+                        : level === "warn"
+                            ? SeverityNumber.WARN
+                            : level === "debug"
+                                ? SeverityNumber.DEBUG
+                                : SeverityNumber.INFO,
+                    attributes: { "proxy.record_kind": "console" },
+                });
+            }
+            catch {
+                invalidRecords++;
+            }
+            finally {
+                emitting = false;
+            }
+        };
+    }
+    restoreConsole = () => Object.assign(console, originals);
+}
+/** Counters acknowledge collector transport only, never backend persistence. */
+export function getProxyOtelLogSnapshot() {
+    return {
+        mode: isProxyOtelOnly() ? "otel" : "file-and-otel",
+        initialized: provider !== undefined,
+        deliveryGuarantee: "best-effort; HTTP success is not per-record acceptance or backend persistence",
+        invalidRecords,
+        queues: queues.map((q, index) => ({
+            kind: index === 0 ? "metadata" : "bodies",
+            capacity: q.capacity,
+            ...q.state,
+        })),
+    };
+}
+/** Bounded provider flush belongs after final request and lifecycle publication. */
+export async function flushProxyOtelLogs() {
+    await provider?.forceFlush();
+}
+/** Release this process's exporter and restore console ownership. */
+export async function shutdownProxyOtelLogs() {
+    restoreConsole?.();
+    restoreConsole = undefined;
+    await provider?.shutdown();
+    provider = undefined;
+    queues.length = 0;
+    invalidRecords = 0;
+}
+/** Flush short-lived proxy command diagnostics on every normal return or exception. */
+export function withProxyOtelLogShutdown(handler) {
+    return async (arg) => {
+        try {
+            await handler(arg);
+        }
+        finally {
+            await flushProxyOtelLogs().catch(() => undefined);
+            await shutdownProxyOtelLogs().catch(() => undefined);
+        }
+    };
+}