@juspay/neurolink 12.13.0 → 12.14.1

package/dist/constants/proxyModels.d.ts

@@ -1,7 +1,7 @@
 /**
  * Model IDs the proxy advertises when no routing config narrows the list.
  *
- * Two consumers need the same answer and must not drift apart:
+ * Three consumers need the same answer and must not drift apart:
  *
  *   - `proxyTranslationEngine` serves them from `GET /v1/models`.
  *   - The OpenCode client configurator writes them into `provider.neurolink.
@@ -9,6 +9,12 @@
  *     It does not call `/v1/models`, so an empty map means every model id is
  *     unknown and `opencode run` fails with `ProviderModelNotFoundError`
  *     before a request is ever made.
+ *   - The Grok Build configurator writes the same ids (plus any
+ *     `routing.model-mappings` in the active proxy config — default
+ *     `~/.neurolink/proxy-config.yaml`, or the path passed to `--config`)
+ *     into `~/.grok/config.toml` as `[model.<id>]` entries, with
+ *     `api_backend` and `context_window` so Grok's compaction matches the
+ *     upstream. Built-in grok-* ids are skipped.
  *
  * Format matches the IDs used throughout `src/lib/models/` and
  * `src/lib/constants/` (e.g. `claude-3-5-haiku-20241022`, not

package/dist/constants/proxyModels.js

@@ -1,7 +1,7 @@
 /**
  * Model IDs the proxy advertises when no routing config narrows the list.
  *
- * Two consumers need the same answer and must not drift apart:
+ * Three consumers need the same answer and must not drift apart:
  *
  *   - `proxyTranslationEngine` serves them from `GET /v1/models`.
  *   - The OpenCode client configurator writes them into `provider.neurolink.
@@ -9,6 +9,12 @@
  *     It does not call `/v1/models`, so an empty map means every model id is
  *     unknown and `opencode run` fails with `ProviderModelNotFoundError`
  *     before a request is ever made.
+ *   - The Grok Build configurator writes the same ids (plus any
+ *     `routing.model-mappings` in the active proxy config — default
+ *     `~/.neurolink/proxy-config.yaml`, or the path passed to `--config`)
+ *     into `~/.grok/config.toml` as `[model.<id>]` entries, with
+ *     `api_backend` and `context_window` so Grok's compaction matches the
+ *     upstream. Built-in grok-* ids are skipped.
  *
  * Format matches the IDs used throughout `src/lib/models/` and
  * `src/lib/constants/` (e.g. `claude-3-5-haiku-20241022`, not

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/clientAttribution.js

@@ -39,6 +39,9 @@ const CLIENT_PREFIXES = [
     // different token, and it is left unmapped until someone measures it rather
     // than pattern-matched on a guess.
     ["codex_exec/", "codex"],
+    // "grok-shell/1.0.30 (macos; aarch64)" — measured 2026-09-12 on
+    // POST /v1/messages from Grok Build 1.0.30.
+    ["grok-shell/", "grok"],
 ];
 /**
  * Deliberately NOT mapped, and why each was ruled out.

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);
+        }
+    };
+}

package/dist/proxy/proxyConfig.d.ts

@@ -11,6 +11,10 @@
  * falls back to JSON.parse.
  */
 import type { LoadProxyConfigOptions, ProxyConfigFile } from "../types/index.js";
+/** Default on-disk path used when `proxy start` is not given `--config`. */
+export declare function defaultProxyConfigPath(): string;
+/** Resolve `--config` the same way `proxy start` / `proxy install` do. */
+export declare function resolveProxyConfigPath(explicit?: string): string;
 /**
  * Replace all `${VAR}` / `${VAR:-default}` references in a string.
  *

package/dist/proxy/proxyConfig.js

@@ -11,9 +11,21 @@
  * falls back to JSON.parse.
  */
 import { readFile } from "node:fs/promises";
-import { extname } from "node:path";
+import { homedir } from "node:os";
+import { extname, join, resolve } from "node:path";
 import { MAX_MAX_INFLIGHT_PER_ACCOUNT, MIN_MAX_INFLIGHT_PER_ACCOUNT, } from "./modelRouter.js";
 import { logger } from "../utils/logger.js";
+/** Default on-disk path used when `proxy start` is not given `--config`. */
+export function defaultProxyConfigPath() {
+    return join(homedir(), ".neurolink", "proxy-config.yaml");
+}
+/** Resolve `--config` the same way `proxy start` / `proxy install` do. */
+export function resolveProxyConfigPath(explicit) {
+    const trimmed = explicit?.trim();
+    return trimmed && trimmed.length > 0
+        ? resolve(trimmed)
+        : defaultProxyConfigPath();
+}
 // ---------------------------------------------------------------------------
 // Environment variable resolution
 // ---------------------------------------------------------------------------

package/dist/proxy/proxyLifecycle.js

@@ -1,3 +1,4 @@
+import { emitProxyOtelEvent, isProxyOtelOnly, initializeProxyOtelLogs, } from "./otelLogSink.js";
 import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
@@ -297,6 +298,25 @@ export function configureProxyLifecycleLogger(options) {
     batchSize = positiveInteger(options.batchSize, DEFAULT_BATCH_SIZE);
     maxWriteRetries = positiveInteger(options.maxWriteRetries, DEFAULT_MAX_WRITE_RETRIES);
     flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+    if (options.enabled && isProxyOtelOnly()) {
+        initializeProxyOtelLogs(options.filePrefix === "proxy-supervisor" ? "supervisor" : "worker");
+        loggerEnabled = true;
+        sessionHashKey = process.env.NEUROLINK_PROXY_SESSION_SECRET
+            ? createHash("sha256")
+                .update(process.env.NEUROLINK_PROXY_SESSION_SECRET)
+                .digest()
+            : sessionHashKey;
+        stopRuntimeMetrics = startProxyRuntimeMetrics((runtimeSample) => {
+            logProxyLifecycleEvent({
+                event: "runtime_sample",
+                requestId: "-",
+                method: "-",
+                path: "-",
+                runtimeSample,
+            });
+        });
+        return;
+    }
     if (options.enabled && options.logDir) {
         try {
             mkdirSync(options.logDir, { recursive: true, mode: 0o700 });
@@ -336,7 +356,7 @@ export function logProxyLifecycleEvent(input) {
  * capacity is unavailable.
  */
 function enqueueLifecycleEvent(input, onPersisted) {
-    if (!loggerEnabled || !lifecycleLogDir) {
+    if (!loggerEnabled || (!lifecycleLogDir && !isProxyOtelOnly())) {
         onPersisted?.(false);
         return;
     }
@@ -406,6 +426,10 @@ function enqueueLifecycleEvent(input, onPersisted) {
                 : {}),
             ...(input.runtimeSample ? { runtimeSample: input.runtimeSample } : {}),
         };
+        if (isProxyOtelOnly()) {
+            emitProxyOtelEvent(filePrefix === "proxy-supervisor" ? "supervisor" : "lifecycle", record);
+            return;
+        }
         queue.push({
             filePrefix,
             logDir: lifecycleLogDir,
@@ -431,6 +455,10 @@ export async function persistProxyLifecycleAcceptance(input, timeoutMs = LIFECYC
     if (!loggerRequired) {
         return;
     }
+    if (isProxyOtelOnly()) {
+        enqueueLifecycleEvent({ ...input, event: "request_accepted" });
+        return;
+    }
     const confirmed = new Promise((resolve) => {
         enqueueLifecycleEvent({ ...input, event: "request_accepted" }, resolve);
     });
@@ -462,6 +490,8 @@ export async function flushProxyLifecycleEvents(timeoutMs = 5_000) {
 export function getProxyLifecycleLoggerSnapshot() {
     return {
         enabled: loggerEnabled,
+        sink: isProxyOtelOnly() ? "otel" : "file",
+        admissionPolicy: isProxyOtelOnly() ? "best-effort" : "durable-file",
         schemaVersion: SCHEMA_VERSION,
         processInstanceId,
         nextSequence,

package/dist/proxy/requestLogger.js

@@ -5,6 +5,7 @@
  * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
+import { emitProxyOtelEvent, getProxyOtelLogSnapshot, initializeProxyOtelLogs, isProxyOtelOnly, } from "./otelLogSink.js";
 import { join } from "path";
 import { homedir } from "os";
 import { logger } from "../utils/logger.js";
@@ -46,6 +47,8 @@ const metadataSinks = {
 export function getRequestLoggerSnapshot() {
     return {
         enabled: logEnabled,
+        diskEnabled: logEnabled && !isProxyOtelOnly(),
+        otel: getProxyOtelLogSnapshot(),
         requests: { ...metadataSinks.requests },
         attempts: { ...metadataSinks.attempts },
         debug: { ...metadataSinks.debug },
@@ -155,6 +158,12 @@ export function initRequestLogger(enabled = true, customLogsDir) {
         configureProxyLifecycleLogger({ enabled: false });
         return;
     }
+    if (isProxyOtelOnly()) {
+        initializeProxyOtelLogs();
+        logDir = null;
+        configureProxyLifecycleLogger({ enabled: true });
+        return;
+    }
     try {
         logDir = customLogsDir ?? join(homedir(), ".neurolink", "logs");
         if (!existsSync(logDir)) {
@@ -183,7 +192,7 @@ export async function logRequest(entry) {
                     ? "handler_error"
                     : "completed";
     notifyProxyFinalLog(entry);
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     // Only use OtelBridge if traceId not already provided by caller.
@@ -197,6 +206,10 @@ export async function logRequest(entry) {
             entry.spanId = traceCtx.spanId;
         }
     }
+    if (isProxyOtelOnly()) {
+        await emitOtlpLogRecord(entry);
+        return;
+    }
     const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
@@ -206,7 +219,7 @@ export async function logRequest(entry) {
         // Non-fatal — don't crash proxy for logging failures
     }
     // Emit OTLP log record (additive — file logging is the primary sink)
-    emitOtlpLogRecord(entry);
+    void emitOtlpLogRecord(entry);
 }
 /**
  * Log an upstream attempt separately from the final request outcome.
@@ -214,7 +227,7 @@ export async function logRequest(entry) {
  * or OTLP-derived dashboard panels.
  */
 export async function logRequestAttempt(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     if (!entry.traceId) {
@@ -225,6 +238,10 @@ export async function logRequestAttempt(entry) {
             entry.spanId = traceCtx.spanId;
         }
     }
+    if (isProxyOtelOnly()) {
+        emitProxyOtelEvent("attempt", entry);
+        return;
+    }
     const logFile = join(logDir, `proxy-attempts-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
@@ -242,6 +259,9 @@ export async function logRequestAttempt(entry) {
  * where OTel initialization completes after the first log request.
  */
 async function resolveLoggerProvider() {
+    if (isProxyOtelOnly()) {
+        return initializeProxyOtelLogs();
+    }
     if (otelLoggerProvider === false) {
         return undefined;
     } // permanently unavailable
@@ -275,7 +295,7 @@ async function resolveLoggerProvider() {
  * Non-blocking, non-fatal — failures are silently swallowed.
  */
 function emitOtlpLogRecord(entry) {
-    resolveLoggerProvider()
+    return resolveLoggerProvider()
         .then((provider) => {
         if (!provider) {
             return;
@@ -293,8 +313,11 @@ function emitOtlpLogRecord(entry) {
         otelLogger.emit({
             severityNumber,
             severityText,
-            body: `${entry.method} ${entry.path} → ${entry.responseStatus} (${entry.responseTimeMs}ms)`,
+            body: isProxyOtelOnly()
+                ? JSON.stringify(entry)
+                : `${entry.method} ${entry.path} → ${entry.responseStatus} (${entry.responseTimeMs}ms)`,
             attributes: {
+                "proxy.record_kind": "request_final",
                 // Core request fields
                 "request.id": entry.requestId,
                 "http.method": entry.method,
@@ -440,6 +463,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
                 body: chunk,
                 attributes: {
                     "event.name": "proxy.body_capture",
+                    "proxy.record_kind": "body",
                     "request.id": entry.requestId,
                     "body.phase": entry.phase,
                     "body.chunk_index": chunkIndex,
@@ -484,7 +508,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
 }
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export async function logBodyCapture(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     // Borrowed traffic is somebody else's conversation. Capturing it would leave
@@ -507,7 +531,9 @@ export async function logBodyCapture(entry) {
         const redactedHeaders = processed.headers;
         const stored = processed.stored;
         const dateStr = new Date(metadata.timestamp).toISOString().split("T")[0];
-        const logFile = join(destination, `proxy-debug-${dateStr}.jsonl`);
+        const logFile = destination
+            ? join(destination, `proxy-debug-${dateStr}.jsonl`)
+            : undefined;
         const indexEntry = {
             timestamp: metadata.timestamp,
             type: "body_capture",
@@ -538,8 +564,13 @@ export async function logBodyCapture(entry) {
             indexEntry.traceId = traceCtx.traceId;
             indexEntry.spanId = traceCtx.spanId;
         }
+        if (isProxyOtelOnly()) {
+            emitProxyOtelEvent("body_capture_index", indexEntry);
+        }
         try {
-            await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug", { waitForPersistence: true });
+            if (logFile) {
+                await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug", { waitForPersistence: true });
+            }
         }
         catch {
             // Non-fatal
@@ -596,12 +627,11 @@ export async function logFullRequestResponse(entry) {
  * These are invisible in normal request logs since the 200 was already recorded.
  */
 export async function logStreamError(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     const bridge = new OtelBridge();
     const traceCtx = bridge.getCurrentTraceContext();
-    const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const logEntry = {
         ...entry,
         responseStatus: 200,
@@ -614,6 +644,11 @@ export async function logStreamError(entry) {
         logEntry.traceId = traceCtx.traceId;
         logEntry.spanId = traceCtx.spanId;
     }
+    if (isProxyOtelOnly()) {
+        emitProxyOtelEvent("stream_error", logEntry);
+        return;
+    }
+    const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     try {
         await appendMetadataRecord(logFile, JSON.stringify(logEntry) + "\n", "requests");
     }