@juspay/neurolink 12.12.9 → 12.12.11

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

@@ -60,6 +60,10 @@ export declare function isRollingHandoffCapable(state: ProxySupervisorState | nu
 export declare function processLooksLikeProxySupervisor(pid: number, expectedStartTimeIso?: string): Promise<boolean>;
 export declare function probeProxyHealth(host: string, port: number, timeoutMs: number): Promise<ProxyHealthProbe>;
 export declare function mapClaudeErrorTypeToStatus(errorType?: string): number;
+/**
+ * Assemble proxy routes with shared admission, runtime error accounting,
+ * and response tracking.
+ */
 export declare function createProxyStartApp(params: {
     neurolink: ProxyNeurolinkRuntime["neurolink"];
     modelRouter: ModelRouterInterface | undefined;

package/dist/cli/commands/proxy.js

@@ -27,11 +27,12 @@ import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.j
 import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
 import { beginProxyRequest, getProxyActivitySnapshot, observeProxyFinalLog, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
-import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
+import { configureProxyLifecycleLogger, flushProxyLifecycleEvents, persistProxyLifecycleAcceptance, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
+import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
 import { attachSocketWorkerProcess } from "../../proxy/socketWorkerRuntime.js";
@@ -1056,7 +1057,12 @@ function redactStatusPrimaryAccount(primary) {
         source: primary.source,
     };
 }
+/**
+ * Confirm durable admission and reconcile route finals with the actual
+ * response transport lifecycle.
+ */
 function registerProxyRequestTracking(app, requestMetadata, readiness) {
+    /** Persist admission before dispatch and observe the response through termination. */
     const trackingHandler = async (c, next) => {
         const startedMonotonicMs = performance.now();
         const contentLengthHeader = c.req.raw.headers.get("content-length");
@@ -1097,17 +1103,16 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         // The route adapter populates model/stream/toolCount after parsing. Omit
         // them at acceptance instead of publishing misleading placeholder values;
         // subsequent events carry the parsed metadata under the same request ID.
-        logProxyLifecycleEvent({
-            event: "request_accepted",
-            requestId: metadata.requestId,
-            method: metadata.method,
-            path: metadata.path,
-            sessionHash,
-            requestBytes,
-            elapsedMs: 0,
-            monotonicMs: startedMonotonicMs,
-        });
         try {
+            await persistProxyLifecycleAcceptance({
+                requestId: metadata.requestId,
+                method: metadata.method,
+                path: metadata.path,
+                sessionHash,
+                requestBytes,
+                elapsedMs: 0,
+                monotonicMs: startedMonotonicMs,
+            });
             await next();
             const responseStatus = c.res.status;
             logProxyLifecycleEvent({
@@ -1180,6 +1185,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         accountingTimedOut = true;
                     }
                     const final = metadata.terminalResult;
+                    const auxiliary = isProxyAuxiliaryRequest(metadata.method, metadata.path);
                     const terminalOutcome = final?.terminalOutcome ??
                         (outcome === "stream_error" ||
                             metadata.terminalErrorType === "stream_error"
@@ -1188,7 +1194,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                                 ? "client_cancelled"
                                 : responseStatus >= 400
                                     ? "handler_error"
-                                    : "unknown");
+                                    : auxiliary
+                                        ? outcome
+                                        : "unknown");
                     logProxyLifecycleEvent({
                         event: "request_terminal",
                         timestampMs: terminalTimestampMs,
@@ -1210,7 +1218,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         transportOutcome: outcome,
                         outcomeSource: final
                             ? "final_request"
-                            : responseStatus >= 400
+                            : responseStatus >= 400 ||
+                                (auxiliary &&
+                                    (outcome === "completed" || outcome === "bodyless"))
                                 ? "http_status"
                                 : terminalOutcome === "unknown"
                                     ? "unknown"
@@ -1219,7 +1229,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                             ? "timeout"
                             : accountingFailed
                                 ? "observer_error"
-                                : final
+                                : final || auxiliary
                                     ? "complete"
                                     : "missing_final",
                         errorType: final?.errorType ?? metadata.terminalErrorType,
@@ -1270,6 +1280,10 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
     app.use("/v1beta/*", trackingHandler);
     app.use("/backend-api/*", trackingHandler);
 }
+/**
+ * Assemble proxy routes with shared admission, runtime error accounting,
+ * and response tracking.
+ */
 export async function createProxyStartApp(params) {
     const { createClaudeProxyRoutes } = await import("../../server/routes/claudeProxyRoutes.js");
     const { createOpenAIProxyRoutes } = await import("../../server/routes/openaiProxyRoutes.js");
@@ -1356,9 +1370,13 @@ export async function createProxyStartApp(params) {
             stream: false,
             toolCount: 0,
         };
-        metadata.terminalErrorType = "unhandled_proxy_error";
         metadata.terminalErrorCode = getProxyRuntimeErrorCode(err);
-        await recordRuntimeError(metadata, 502, "unhandled_proxy_error", errMsg, {
+        const telemetryUnavailable = metadata.terminalErrorCode === "PROXY_TELEMETRY_UNAVAILABLE";
+        const status = telemetryUnavailable ? 503 : 502;
+        metadata.terminalErrorType = telemetryUnavailable
+            ? "telemetry_unavailable"
+            : "unhandled_proxy_error";
+        await recordRuntimeError(metadata, status, metadata.terminalErrorType, errMsg, {
             clientMessage: "Proxy internal error",
             clientErrorType: "api_error",
             errorCode: metadata.terminalErrorCode,
@@ -1370,7 +1388,7 @@ export async function createProxyStartApp(params) {
                 type: "api_error",
                 message: "Proxy internal error",
             },
-        }, 502);
+        }, status);
     });
     app.post("/internal/update-control", async (c) => {
         const suppliedToken = c.req.header("x-neurolink-update-token");
@@ -2270,6 +2288,7 @@ function startProxyBackgroundMaintenance(logsDir, getAccountAllowlist) {
     const logCleanupScheduler = startProxyLogCleanupScheduler({ logsDir });
     return { refreshInterval, logCleanupScheduler };
 }
+/** Register signal handlers and return the shared, idempotent drain-and-flush operation. */
 function registerProxyShutdownHandlers(params) {
     let shutdownStarted = false;
     /**
@@ -2329,6 +2348,7 @@ function registerProxyShutdownHandlers(params) {
             }
         });
     };
+    /** Stop background work, drain connections, and flush pending telemetry before exit. */
     const shutdown = async (signal, options) => {
         if (shutdownStarted) {
             return;
@@ -2359,7 +2379,9 @@ function registerProxyShutdownHandlers(params) {
         const [usageStatsFlushResult, lifecycleFlushResult, requestLogsFlushResult,] = await Promise.allSettled([
             withTimeout(usageStatsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy usage statistics during shutdown"),
             withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown"),
-            withTimeout(requestLogsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy request logs during shutdown"),
+            // This flush owns a separate bounded budget covering the body worker
+            // deadline plus index/OTLP publication; do not truncate it to five seconds.
+            requestLogsFlush,
         ]);
         if (usageStatsFlushResult.status === "rejected") {
             const error = usageStatsFlushResult.reason;
@@ -2413,6 +2435,7 @@ function registerProxyShutdownHandlers(params) {
     }
     return shutdown;
 }
+/** Start the HTTP runtime and connect its worker, configuration, and shutdown lifecycles. */
 async function startProxyRuntime(params) {
     const socketWorker = isProxySocketWorkerProcess();
     const { createAdaptorServer, serve } = await import("@hono/node-server");
@@ -2716,6 +2739,7 @@ async function startProxyRuntime(params) {
         attachSocketWorkerProcess(server, {
             generation: getProxyWorkerGeneration(),
             version: PROXY_VERSION,
+            processInstanceId: getProxyLifecycleLoggerSnapshot().processInstanceId,
             onActivated: () => {
                 persistInitialProxyState();
                 void reconcileActivatedUpdate();
@@ -2726,6 +2750,10 @@ async function startProxyRuntime(params) {
         });
     }
 }
+/**
+ * Run the stable listener and journal worker incidents independently of
+ * serving-process exits.
+ */
 async function runLaunchdProxySupervisor(argv, spinner) {
     await ensureProxyStartAllowed(spinner);
     const entryScript = process.argv[1];
@@ -2736,8 +2764,20 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     const port = argv.port ?? 55669;
     const workerArgs = process.argv.slice(2);
     const supervisorStartedAt = new Date().toISOString();
+    configureProxyLifecycleLogger({
+        enabled: true,
+        logDir: join(homedir(), ".neurolink", "logs"),
+        filePrefix: "proxy-supervisor",
+    });
     let currentUpdaterPid;
     const rollingServer = await startRollingProxyServer({
+        onEvent: (event) => logProxyLifecycleEvent({
+            event: "supervisor_event",
+            requestId: "-",
+            method: "-",
+            path: "-",
+            supervisorEvent: event,
+        }),
         host,
         port,
         initialVersion: PROXY_VERSION,
@@ -2817,6 +2857,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     }
     logger.always(`[proxy-supervisor] listening on ${host}:${rollingServer.address.port} workerPid=${rollingServer.snapshot().active?.pid ?? "unknown"} version=${PROXY_VERSION}`);
     let stopping = false;
+    /** Drain the rolling workers and flush the supervisor journal before clearing ownership. */
     const shutdown = async (signal) => {
         if (stopping) {
             return;
@@ -2826,6 +2867,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         process.off("SIGUSR2", activatePendingUpdate);
         updaterSupervisor.stop();
         await rollingServer.close();
+        await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
         const supervisorState = loadProxySupervisorState();
         if (supervisorState?.pid === process.pid) {
             clearProxySupervisorState();

package/dist/cli/commands/proxyAnalyze.js

@@ -5,6 +5,10 @@ function formatLatency(label, summary) {
     const value = (amount) => amount === null ? "-" : amount.toFixed(1);
     return `${label.padEnd(22)} ${String(summary.count).padStart(7)} ${value(summary.p50).padStart(9)} ${value(summary.p95).padStart(9)} ${value(summary.p99).padStart(9)} ${value(summary.max).padStart(9)}`;
 }
+/**
+ * Render the offline evidence report without converting missing outcomes
+ * into inferred success.
+ */
 function printAnalysis(report) {
     logger.always("");
     logger.always(chalk.bold.cyan("NeuroLink Proxy Analysis"));
@@ -33,8 +37,11 @@ function printAnalysis(report) {
         }
     }
     logger.always(report.coverage.lifecycle
-        ? `    Lifecycle: ${report.lifecycle.accepted} accepted, ${report.lifecycle.terminal} terminal, ${report.lifecycle.unsettled} unsettled`
+        ? `    Lifecycle: ${report.lifecycle.accepted} accepted (${report.lifecycle.auxiliaryRequests} auxiliary), ${report.lifecycle.terminal} terminal, ${report.lifecycle.unsettled} unsettled (${report.lifecycle.unconfirmedAtWorkerExit.length} unconfirmed at worker exit)`
         : chalk.yellow("    Lifecycle: unavailable (no lifecycle metadata)"));
+    if (report.runtime.samples > 0) {
+        logger.always(`    Runtime: ${report.runtime.samples} samples, max event-loop delay ${report.runtime.maxEventLoopDelayMs ?? "unknown"}ms, max CPU ${report.runtime.maxCpuPercentOneCore?.toFixed(1) ?? "unknown"}% of one core, max host load ${report.runtime.maxHostLoad1m ?? "unknown"}`);
+    }
     if (report.coverage.attempts) {
         const finalRateLimits = report.coverage.finalRequests
             ? `${report.requests.finalRateLimits} final`

package/dist/core/baseProvider.d.ts

@@ -22,7 +22,6 @@ export declare abstract class BaseProvider implements AIProvider {
     } | null): void;
     private messageBuilder;
     private streamHandler;
-    private generationHandler;
     protected telemetryHandler: TelemetryHandler;
     private utilities;
     private readonly toolsManager;
@@ -185,30 +184,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns Promise resolving to ModelMessage array ready for AI SDK
      */
     protected buildMessagesForStream(options: StreamOptions | TextGenerationOptions): Promise<ModelMessage[]>;
-    /**
-     * Execute the generation with AI SDK - delegated to GenerationHandler
-     */
-    private executeGeneration;
-    /**
-     * Log generation completion information - delegated to GenerationHandler
-     */
-    private logGenerationComplete;
     /**
      * Record performance metrics - delegated to TelemetryHandler
      */
     protected recordPerformanceMetrics(usage: RawUsageObject | undefined, responseTime: number): Promise<void>;
-    /**
-     * Extract tool information from generation result - delegated to GenerationHandler
-     */
-    private extractToolInformation;
-    /**
-     * Format the enhanced result - delegated to GenerationHandler
-     */
-    private formatEnhancedResult;
-    /**
-     * Analyze AI response structure and log detailed debugging information - delegated to GenerationHandler
-     */
-    private analyzeAIResponse;
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
@@ -281,7 +260,6 @@ export declare abstract class BaseProvider implements AIProvider {
     private runGenerateInActiveContext;
     protected handleDirectTTSSynthesis(options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
     private handleVideoFrameGeneration;
-    private executeStandardGenerateFlow;
     /**
      * Close out a turn produced by a provider's own native generate loop.
      *

package/dist/core/baseProvider.js

@@ -32,14 +32,13 @@ import { TimeoutError as AsyncTimeoutError, withTimeoutFn, } from "../utils/asyn
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
-import { ToolExecutionRecorder, resolveToolExecutionRecords, } from "./toolExecutionRecorder.js";
+import { ToolExecutionRecorder } from "./toolExecutionRecorder.js";
 import { TTS_ERROR_CODES, TTSProcessor } from "../utils/ttsProcessor.js";
 import { executeVideoAnalysis, hasVideoFrames, } from "../utils/videoAnalysisProcessor.js";
 import { dedupeTools } from "./toolDedup.js";
 import { resolveToolPolicy, toolNameMatcher } from "../tools/toolPolicy.js";
 import { applyToolGate } from "../tools/toolGate.js";
 import { partitionToolsForDiscovery, isDiscoveryMetaTool, LARGE_CATALOG_WARN_THRESHOLD, } from "../tools/toolDiscovery.js";
-import { GenerationHandler } from "./modules/GenerationHandler.js";
 // Import modules for composition
 import { MessageBuilder } from "./modules/MessageBuilder.js";
 import { StreamHandler } from "./modules/StreamHandler.js";
@@ -137,7 +136,6 @@ export class BaseProvider {
     // alone.
     messageBuilder;
     streamHandler;
-    generationHandler;
     telemetryHandler;
     utilities;
     toolsManager;
@@ -150,7 +148,6 @@ export class BaseProvider {
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
-        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), { getEmitterFn: () => this.neurolink?.getEventEmitter() });
         this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
         this.toolsManager = new ToolsManager(this.providerName, this.directTools, this.neurolink, {
             isZodSchema: (schema) => this.isZodSchema(schema),
@@ -175,7 +172,6 @@ export class BaseProvider {
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
-        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), { getEmitterFn: () => this.neurolink?.getEventEmitter() });
         this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
     }
     /**
@@ -1202,42 +1198,12 @@ export class BaseProvider {
     async buildMessagesForStream(options) {
         return this.messageBuilder.buildMessagesForStream(options);
     }
-    /**
-     * Execute the generation with AI SDK - delegated to GenerationHandler
-     */
-    async executeGeneration(model, messages, tools, options) {
-        return this.generationHandler.executeGeneration(model, messages, tools, options);
-    }
-    /**
-     * Log generation completion information - delegated to GenerationHandler
-     */
-    logGenerationComplete(generateResult) {
-        this.generationHandler.logGenerationComplete(generateResult);
-    }
     /**
      * Record performance metrics - delegated to TelemetryHandler
      */
     async recordPerformanceMetrics(usage, responseTime) {
         await this.telemetryHandler.recordPerformanceMetrics(usage, responseTime);
     }
-    /**
-     * Extract tool information from generation result - delegated to GenerationHandler
-     */
-    extractToolInformation(generateResult) {
-        return this.generationHandler.extractToolInformation(generateResult);
-    }
-    /**
-     * Format the enhanced result - delegated to GenerationHandler
-     */
-    formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options) {
-        return this.generationHandler.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options);
-    }
-    /**
-     * Analyze AI response structure and log detailed debugging information - delegated to GenerationHandler
-     */
-    analyzeAIResponse(result) {
-        this.generationHandler.analyzeAIResponse(result);
-    }
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
@@ -1398,13 +1364,28 @@ export class BaseProvider {
             if (requestKind === "tts-direct") {
                 return this.handleDirectTTSSynthesis(options, startTime);
             }
-            const { tools, model } = await this.prepareGenerationContext(options);
+            // Only `model` is used now — the video-frame path needs it. `tools`
+            // fed the standard generate flow, which no longer exists.
+            const { model } = await this.prepareGenerationContext(options);
             const messages = await this.buildMessages(options);
             const videoFrameResult = await this.handleVideoFrameGeneration(options, messages, model, startTime);
             if (videoFrameResult) {
                 return videoFrameResult;
             }
-            return await this.executeStandardGenerateFlow(options, startTime, model, messages, tools);
+            // Every provider that generates text overrides `generate()` and runs a
+            // native loop. There is no shared fallback any more: the standard flow
+            // called the ai package's `generateText`, and once that was gone the
+            // flow could only throw. Reaching here means a provider was asked for
+            // text without implementing it — an image or embedding provider handed
+            // a text model, or a new subclass with no `generate()` yet.
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_CONFIGURATION,
+                message: `${this.providerName} cannot generate text: it does not override generate(). Every text provider implements a native generate() — see docs/plans/2026-09-03-completing-the-ai-sdk-removal.md`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.CRITICAL,
+                retriable: false,
+                context: { provider: this.providerName, model: this.modelName },
+            });
         }
         catch (error) {
             otelSpan.setStatus({
@@ -1537,50 +1518,6 @@ export class BaseProvider {
             usage,
         }, options, startTime);
     }
-    async executeStandardGenerateFlow(options, startTime, model, messages, tools) {
-        // Apply a defensive default timeout when the caller didn't pass one.
-        // Without this guard, AI SDK's generateText() will wait forever on
-        // an upstream that accepts the connection but never produces a response
-        // (observed against the litellm gateway when a request triggers the
-        // team-access denial path — connection stays open, no response is sent,
-        // and the matrix test hangs the entire suite). Callers can still pass
-        // a larger value (e.g. video generation passes 10 min).
-        //
-        // A provider descriptor may declare a LARGER generate budget than the
-        // 3-min floor (litellm: 300s — slow proxied models routinely need more
-        // than 180s end-to-end even while streaming). The declared value only
-        // ever raises the default, never lowers it: several descriptors carry
-        // aspirational sub-180s numbers (openai 30s, bedrock 45s) that were
-        // never enforced on this path, and enforcing them now would break
-        // long-running generations that have always been allowed.
-        const descriptorGenerateMs = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts?.generateMs;
-        // An explicit, valid turnTimeoutMs is the caller's whole-turn contract
-        // and owns this hard abort; `timeout` then keeps its per-model-call
-        // meaning (it reaches the model layer via providerOptions.neurolink).
-        // Before this, `timeout` alone bounded the ENTIRE multi-step loop, so a
-        // caller asking for a 40-minute turn of 5-minute calls was killed at 5
-        // minutes flat — mid-loop, dressed as "Request was aborted.".
-        const generateResult = await this.withTurnTimeout(options, descriptorGenerateMs, (timedOptions) => this.executeGeneration(model, messages, tools, timedOptions));
-        this.analyzeAIResponse(generateResult);
-        this.logGenerationComplete(generateResult);
-        const responseTime = Date.now() - startTime;
-        const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
-        // Prefer the per-call recorder's real records (params/result/timing per
-        // execution); fall back to a conversion of the step-extraction entries
-        // for tools the recorder could not wrap (provider-executed tools).
-        const toolExecutionRecords = resolveToolExecutionRecords(options, toolExecutions);
-        let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutionRecords, options);
-        // Recorded AFTER formatEnhancedResult so telemetry sees the same usage
-        // the caller gets: the cross-step aggregate (totalUsage, not last-step
-        // usage) WITH the providerMetadata cache merge applied — otherwise
-        // providers whose cache data lives only in providerMetadata would have
-        // their cache tokens billed at the full input rate in OTEL metrics,
-        // diverging from analytics.cost.
-        await this.recordPerformanceMetrics(enhancedResult.usage, responseTime);
-        enhancedResult = await this.synthesizeAIResponseIfNeeded(enhancedResult, options);
-        const finalResult = await this.enhanceResult(enhancedResult, options, startTime);
-        return finalResult;
-    }
     /**
      * Close out a turn produced by a provider's own native generate loop.
      *

package/dist/providers/anthropic/client.js

@@ -1280,7 +1280,10 @@ export class AnthropicProvider extends BaseProvider {
                 };
             },
             doStream: () => {
-                throw new Error(`${providerName}: doStream is not implemented on the delegating model — the streaming path uses executeStream directly.`);
+                throw new Error(`${providerName}: doStream is not implemented on the delegating model. ` +
+                    `NeuroLink streams through executeStream, reached via NeuroLink.stream() — ` +
+                    `use that (the browser bundle exports the NeuroLink class) rather than ` +
+                    `calling doStream on a model handle.`);
             },
         };
         return delegatingModel;

package/dist/providers/openaiChatCompletionsBase.js

@@ -784,7 +784,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 };
             },
             doStream: () => {
-                throw new Error(`${providerName}: doStream is not implemented on the delegating model — the streaming path uses executeStream directly.`);
+                throw new Error(`${providerName}: doStream is not implemented on the delegating model. ` +
+                    `NeuroLink streams through executeStream, reached via NeuroLink.stream() — ` +
+                    `use that (the browser bundle exports the NeuroLink class) rather than ` +
+                    `calling doStream on a model handle.`);
             },
         };
     }

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -0,0 +1,22 @@
+import type { ProxyBodyCaptureEntry, ProcessedProxyBodyCapture } from "../types/index.js";
+/**
+ * Split redacted text into byte-bounded OTLP chunks without splitting
+ * encoded characters.
+ */
+export declare function splitUtf8StringByBytes(input: string, maxBytes: number): string[];
+/** Shared pure redaction for replay; serving paths invoke it in the worker. */
+export declare function prepareProxyBodyForLogging(body: unknown): {
+    value?: string;
+    bytes?: number;
+    truncated: boolean;
+};
+/**
+ * Expose the same header-redaction policy to replay and metadata
+ * consumers.
+ */
+export declare function redactProxyHeadersForLogging(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+/**
+ * Process a capture in the worker and retain redacted output when artifact
+ * persistence fails.
+ */
+export declare function processProxyBodyCapture(entry: ProxyBodyCaptureEntry, logDir: string): Promise<ProcessedProxyBodyCapture>;