@juspay/neurolink 12.48.1 → 12.49.0

package/dist/processors/media/VideoProcessor.js

@@ -51,6 +51,9 @@ import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { formatKeyframeTimestamp, formatMediaDuration, } from "../../utils/mediaDuration.js";
+import { getSTTProviderDescriptor, resolveDefaultSTTProvider, STT_PROVIDER_DESCRIPTORS, } from "../../factories/sttDescriptors.js";
+import { STTProcessor } from "../../utils/sttProcessor.js";
+import { freshEnvSTTCredentials } from "../../voice/sttEnvCredentials.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { extensionsForModality, mimeTypesForModality, } from "../config/fileTypeRegistry.js";
 import { FileErrorCode } from "../errors/index.js";
@@ -211,10 +214,11 @@ const VIDEO_CONFIG = {
      * seeking to a handful of offsets, and a meeting recording is long.
      */
     AUDIO_EXTRACT_TIMEOUT_MS: 180_000,
-    /** Timeout for one Whisper transcription request in milliseconds */
+    /** Timeout for one transcription request in milliseconds */
     TRANSCRIPTION_TIMEOUT_MS: 120_000,
     /**
-     * Whisper's upload ceiling in MB. The extracted track is mono 16 kHz MP3,
+     * Transcription upload ceiling in MB (Whisper's documented limit, and a
+     * floor for the other engines). The extracted track is mono 16 kHz MP3,
      * so this is roughly six hours of speech — a clip that breaches it is
      * unusual enough to be worth saying so rather than silently truncating.
      */
@@ -853,11 +857,9 @@ export class VideoProcessor extends BaseFileProcessor {
      * working implementation of the same thing, and `--transcribe-audio` would
      * still do nothing.
      *
-     * The Whisper call is reproduced here rather than shared with
-     * `AudioProcessor`: extracting it into a common module is the better
-     * long-term shape, but that file is being edited concurrently, and a
-     * merge conflict in the audio pipeline is a worse outcome than fifty
-     * duplicated lines. The duplication is worth removing once both land.
+     * The call goes through `STTProcessor`, like `AudioProcessor` and
+     * `transcribe()`, so the default-provider rule, `OPENAI_STT_*` and every
+     * STT handler apply to video too.
      *
      * ## Failure behaviour
      *
@@ -890,11 +892,35 @@ export class VideoProcessor extends BaseFileProcessor {
         if (!metadata.audioCodec) {
             return skipped("the video has no audio track");
         }
-        const apiKey = process.env.OPENAI_API_KEY;
-        if (!apiKey) {
-            return skipped("OPENAI_API_KEY is not set, and Whisper is the only transcription backend wired up");
+        // The same provider rule as every other transcription: the provider named
+        // by NEUROLINK_STT_PROVIDER, else the first configured one, else the
+        // built-in local engine when it can run here.
+        const provider = resolveDefaultSTTProvider();
+        const descriptor = getSTTProviderDescriptor(provider);
+        // Same slice AudioProcessor builds, from one shared helper, so audio
+        // attachments and video audio tracks can never resolve different endpoints.
+        const credentials = descriptor
+            ? freshEnvSTTCredentials(descriptor.credentialsKey)
+            : {};
+        let handler;
+        try {
+            handler = await STTProcessor.resolveHandler(provider, credentials);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            return skipped(`the transcription backend could not be loaded — ${detail}`);
         }
-        const audioPath = join(tempDir, "audio.mp3");
+        if (!handler?.isConfigured()) {
+            return skipped(descriptor?.capabilities.local
+                ? `no transcription backend is configured — set one of: ${STT_PROVIDER_DESCRIPTORS.flatMap((d) => d.envVars).join(", ")}`
+                : `transcription provider "${provider}" is not configured`);
+        }
+        const label = provider === "whisper" ? "openai-whisper" : provider;
+        // MP3 keeps a long recording under the upload ceiling; an engine that
+        // does not read MP3 gets 16-bit PCM WAV instead.
+        const supported = handler.getSupportedFormats();
+        const audioFormat = supported.length === 0 || supported.includes("mp3") ? "mp3" : "wav";
+        const audioPath = join(tempDir, `audio.${audioFormat}`);
         try {
             await runFfmpeg([
                 "-y",
@@ -905,16 +931,15 @@ export class VideoProcessor extends BaseFileProcessor {
                 // Drop the video stream outright. Without -vn ffmpeg tries to carry
                 // it into an MP3 container as cover art and fails on most inputs.
                 "-vn",
-                // Mono at 16 kHz is what Whisper resamples to anyway, and it keeps
-                // an hour-long recording comfortably under the upload ceiling.
+                // Mono at 16 kHz is what speech engines resample to anyway, and it
+                // keeps an hour-long recording comfortably under the upload ceiling.
                 "-ac",
                 "1",
                 "-ar",
                 "16000",
-                "-c:a",
-                "libmp3lame",
-                "-q:a",
-                "4",
+                ...(audioFormat === "mp3"
+                    ? ["-c:a", "libmp3lame", "-q:a", "4"]
+                    : ["-c:a", "pcm_s16le"]),
                 audioPath,
             ], { timeoutMs: VIDEO_CONFIG.AUDIO_EXTRACT_TIMEOUT_MS });
         }
@@ -934,52 +959,28 @@ export class VideoProcessor extends BaseFileProcessor {
         }
         const sizeMB = audioBuffer.length / (1024 * 1024);
         if (sizeMB > VIDEO_CONFIG.WHISPER_MAX_SIZE_MB) {
-            return skipped(`the extracted audio is ${sizeMB.toFixed(1)}MB, over Whisper's ` +
-                `${VIDEO_CONFIG.WHISPER_MAX_SIZE_MB}MB limit — split the recording`);
+            return skipped(`the extracted audio is ${sizeMB.toFixed(1)}MB, over the ` +
+                `${VIDEO_CONFIG.WHISPER_MAX_SIZE_MB}MB transcription limit — split the recording`);
         }
-        const baseUrl = (process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1").replace(/\/+$/, "");
-        const form = new FormData();
-        form.append("file", new Blob([new Uint8Array(audioBuffer)], { type: "audio/mpeg" }), "audio.mp3");
-        form.append("model", "whisper-1");
-        form.append("response_format", "verbose_json");
-        // `withTimeout` only races a promise against a timer — it cannot cancel
-        // the request. Without the abort, a timed-out upload keeps its socket and
-        // its in-flight body alive after the caller has already moved on.
-        const abort = new AbortController();
-        const timer = setTimeout(() => abort.abort(), VIDEO_CONFIG.TRANSCRIPTION_TIMEOUT_MS);
         try {
-            const response = await withTimeout(fetch(`${baseUrl}/audio/transcriptions`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${apiKey}` },
-                body: form,
-                signal: abort.signal,
-            }), VIDEO_CONFIG.TRANSCRIPTION_TIMEOUT_MS);
-            if (!response.ok) {
-                const detail = await response.text().catch(() => "");
-                return skipped(`the transcription request failed — HTTP ${response.status}` +
-                    `${detail ? `: ${detail.slice(0, 200)}` : ""}`);
-            }
-            const payload = await response.json();
-            const text = typeof payload === "object" &&
-                payload !== null &&
-                typeof payload.text === "string"
-                ? payload.text.trim()
-                : "";
+            const result = await withTimeout(STTProcessor.transcribe(audioBuffer, provider, {
+                format: audioFormat,
+                timeoutMs: VIDEO_CONFIG.TRANSCRIPTION_TIMEOUT_MS,
+                maxAudioBytes: VIDEO_CONFIG.WHISPER_MAX_SIZE_MB * 1024 * 1024,
+            }, credentials), VIDEO_CONFIG.TRANSCRIPTION_TIMEOUT_MS);
+            const text = result.text.trim();
             if (text.length === 0) {
                 // A successful call returning nothing is a real outcome — silence,
                 // music, no speech — and not the same as a failure.
-                return skipped("Whisper returned an empty transcript for this audio");
+                return skipped(`${provider === "whisper" ? "Whisper" : label} returned an empty transcript for this audio`);
             }
-            logger.debug(`[VideoProcessor] Transcribed ${filename} via openai-whisper (${text.length} chars)`);
+            logger.debug(`[VideoProcessor] Transcribed ${filename} via ${label} (${text.length} chars)`);
             return { transcript: text };
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
             return skipped(`the transcription request failed — ${detail}`);
         }
-        finally {
-            clearTimeout(timer);
-        }
     }
     /**
      * Extract keyframes from a video at calculated intervals.

package/dist/server/abstract/baseServerAdapter.d.ts

@@ -7,7 +7,7 @@ import { EventEmitter } from "events";
 import type { ExternalServerManager } from "../../mcp/externalServerManager.js";
 import type { MCPToolRegistry } from "../../mcp/toolRegistry.js";
 import type { NeuroLink } from "../../neurolink.js";
-import type { MiddlewareDefinition, RedactionConfig, RequiredServerAdapterConfig, RequiredShutdownConfig, RouteDefinition, ServerAdapterConfig, ServerContext, ServerLifecycleState, ServerStatus, TrackedConnection } from "../../types/index.js";
+import type { MiddlewareDefinition, RedactionConfig, RequiredServerAdapterConfig, RequiredShutdownConfig, RouteDefinition, ServerAdapterConfig, ServerAdapterEvents, ServerContext, ServerLifecycleState, ServerStatus, TrackedConnection } from "../../types/index.js";
 /**
  * Abstract base class for server adapters
  * Provides common functionality and defines the interface for framework-specific implementations
@@ -22,6 +22,9 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
     protected middlewares: MiddlewareDefinition[];
     protected isRunning: boolean;
     protected startTime?: Date;
+    private frameworkReady;
+    private pendingMiddlewares;
+    private pendingRouteKeys;
     protected lifecycleState: ServerLifecycleState;
     protected activeConnections: Map<string, TrackedConnection>;
     protected readonly shutdownConfig: RequiredShutdownConfig;
@@ -54,6 +57,13 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
      * Get the underlying framework instance (for advanced usage)
      */
     abstract getFrameworkInstance(): unknown;
+    /**
+     * The listening Node `http.Server`, once `start()` has run and the runtime
+     * is Node (Bun and Deno serve without one). A WebSocket upgrade handler
+     * such as `attachTranscribeWebSocket` attaches to it; `undefined` means
+     * there is nothing to attach to.
+     */
+    getNativeServer(): unknown;
     /**
      * Stop accepting new connections
      * Called during graceful shutdown to prevent new requests
@@ -107,6 +117,23 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
      * Register custom middleware
      */
     registerMiddleware(middleware: MiddlewareDefinition): void;
+    /**
+     * Log a failed request. A client error (a rejected API key, a failed
+     * validation) is routine traffic, so it is a one-line warning rather than
+     * an error with a stack trace that anyone could flood the logs with.
+     */
+    protected logRequestError(source: string, requestId: string | undefined, error: Error): void;
+    /**
+     * Notify "error" listeners about a failed request. EventEmitter throws when
+     * "error" has no listener, which inside a framework's error handler turns
+     * every failure into an empty 500, so emit only when someone is listening.
+     */
+    protected emitRequestError(payload: ServerAdapterEvents["error"]): void;
+    /**
+     * Hand queued registrations to the framework. A route re-registered under
+     * the same key before initialize() is replayed once, in its final form.
+     */
+    private flushPendingRegistrations;
     /**
      * Create request context from incoming request
      */

package/dist/server/abstract/baseServerAdapter.js

@@ -8,7 +8,7 @@ import { getMetricsAggregator, SpanSerializer, SpanStatus, SpanType, } from "../
 import { withTimeout } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { tryImport } from "../../utils/tryImport.js";
-import { DrainTimeoutError, InvalidLifecycleStateError, MissingDependencyError, ShutdownTimeoutError, } from "../errors.js";
+import { DrainTimeoutError, InvalidLifecycleStateError, MissingDependencyError, ServerAdapterError, ShutdownTimeoutError, } from "../errors.js";
 /**
  * Abstract base class for server adapters
  * Provides common functionality and defines the interface for framework-specific implementations
@@ -23,6 +23,12 @@ export class BaseServerAdapter extends EventEmitter {
     middlewares = [];
     isRunning = false;
     startTime;
+    // Adapters build their framework app lazily in initialize(), so routes and
+    // middleware registered before that are queued here and replayed once the
+    // app exists — middleware first, so it still guards those routes.
+    frameworkReady = false;
+    pendingMiddlewares = [];
+    pendingRouteKeys = new Set();
     // Lifecycle management properties
     lifecycleState = "uninitialized";
     activeConnections = new Map();
@@ -47,7 +53,10 @@ export class BaseServerAdapter extends EventEmitter {
             basePath: config.basePath ?? "/api",
             cors: {
                 enabled: config.cors?.enabled ?? true,
-                origins: config.cors?.origins ?? ["*"],
+                // No origin by default: a browser page may call this server only
+                // from an origin the operator listed, or from any origin with an
+                // explicit ["*"]. The adapters honour the wildcard, so it is opt-in.
+                origins: config.cors?.origins ?? [],
                 methods: config.cors?.methods ?? [
                     "GET",
                     "POST",
@@ -92,6 +101,15 @@ export class BaseServerAdapter extends EventEmitter {
             shutdown: this.shutdownConfig,
         };
     }
+    /**
+     * The listening Node `http.Server`, once `start()` has run and the runtime
+     * is Node (Bun and Deno serve without one). A WebSocket upgrade handler
+     * such as `attachTranscribeWebSocket` attaches to it; `undefined` means
+     * there is nothing to attach to.
+     */
+    getNativeServer() {
+        return undefined;
+    }
     // ============================================
     // Common Methods (Shared Implementation)
     // ============================================
@@ -146,8 +164,11 @@ export class BaseServerAdapter extends EventEmitter {
         try {
             // Initialize framework-specific setup
             await this.initializeFramework();
+            this.frameworkReady = true;
             // Register built-in middleware
             this.registerBuiltInMiddleware();
+            // Replay what callers registered before the framework app existed
+            this.flushPendingRegistrations();
             // Register built-in routes
             await this.registerBuiltInRoutes();
             this.lifecycleState = "initialized";
@@ -183,7 +204,12 @@ export class BaseServerAdapter extends EventEmitter {
             logger.warn(`[ServerAdapter] Route ${routeKey} already exists, replacing`);
         }
         this.routes.set(routeKey, route);
-        this.registerFrameworkRoute(route);
+        if (this.frameworkReady) {
+            this.registerFrameworkRoute(route);
+        }
+        else {
+            this.pendingRouteKeys.add(routeKey);
+        }
         logger.debug(`[ServerAdapter] Registered route: ${routeKey}`, {
             description: route.description,
             streaming: route.streaming?.enabled,
@@ -231,12 +257,66 @@ export class BaseServerAdapter extends EventEmitter {
      */
     registerMiddleware(middleware) {
         this.middlewares.push(middleware);
-        this.registerFrameworkMiddleware(middleware);
+        if (this.frameworkReady) {
+            this.registerFrameworkMiddleware(middleware);
+        }
+        else {
+            this.pendingMiddlewares.push(middleware);
+        }
         logger.debug(`[ServerAdapter] Registered middleware: ${middleware.name}`, {
             order: middleware.order,
             paths: middleware.paths,
         });
     }
+    /**
+     * Log a failed request. A client error (a rejected API key, a failed
+     * validation) is routine traffic, so it is a one-line warning rather than
+     * an error with a stack trace that anyone could flood the logs with.
+     */
+    logRequestError(source, requestId, error) {
+        if (error instanceof ServerAdapterError && error.getHttpStatus() < 500) {
+            logger.warn(`[${source}] Request rejected`, {
+                requestId,
+                code: error.code,
+                error: error.message,
+            });
+            return;
+        }
+        logger.error(`[${source}] Request error`, {
+            requestId,
+            error: error.message,
+            stack: error.stack,
+        });
+    }
+    /**
+     * Notify "error" listeners about a failed request. EventEmitter throws when
+     * "error" has no listener, which inside a framework's error handler turns
+     * every failure into an empty 500, so emit only when someone is listening.
+     */
+    emitRequestError(payload) {
+        if (this.listenerCount("error") > 0) {
+            this.emit("error", payload);
+        }
+    }
+    /**
+     * Hand queued registrations to the framework. A route re-registered under
+     * the same key before initialize() is replayed once, in its final form.
+     */
+    flushPendingRegistrations() {
+        const middlewares = this.pendingMiddlewares;
+        const routeKeys = this.pendingRouteKeys;
+        this.pendingMiddlewares = [];
+        this.pendingRouteKeys = new Set();
+        for (const middleware of middlewares) {
+            this.registerFrameworkMiddleware(middleware);
+        }
+        for (const routeKey of routeKeys) {
+            const route = this.routes.get(routeKey);
+            if (route) {
+                this.registerFrameworkRoute(route);
+            }
+        }
+    }
     /**
      * Create request context from incoming request
      */

package/dist/server/adapters/expressAdapter.d.ts

@@ -67,4 +67,5 @@ export declare class ExpressServerAdapter extends BaseServerAdapter {
      * Get the Express app instance
      */
     getFrameworkInstance(): unknown;
+    getNativeServer(): unknown;
 }

package/dist/server/adapters/expressAdapter.js

@@ -6,6 +6,7 @@ import { logger } from "../../utils/logger.js";
 import { AlreadyRunningError, ServerAdapterError, ServerStartError, ServerStopError, wrapError, } from "../errors.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import { isErrorResponse } from "../utils/validation.js";
+import { isRawBodyContentType, isWebResponse, readWebResponse, } from "../utils/rawBody.js";
 /**
  * Express-specific server adapter
  */
@@ -42,13 +43,23 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                 "10mb";
             this.app.use(express.json({ limit: this.config.bodyParser.jsonLimit || bodyLimit }));
             this.app.use(express.urlencoded({ extended: true, limit: bodyLimit }));
+            // 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",
+            }));
         }
         // CORS
         if (this.config.cors.enabled) {
             const corsModule = await this.importFrameworkDependency("cors", "Express");
             const cors = corsModule.default;
             this.app.use(cors({
-                origin: this.config.cors.origins,
+                // A list is matched literally, so the default `["*"]` would match
+                // nothing; the wildcard has to be the string "*" (Koa handles it in
+                // its origin callback).
+                origin: this.config.cors.origins.includes("*")
+                    ? "*"
+                    : this.config.cors.origins,
                 methods: this.config.cors.methods,
                 allowedHeaders: this.config.cors.headers,
                 credentials: this.config.cors.credentials,
@@ -170,6 +181,24 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                 // Execute handler
                 const result = await route.handler(ctx);
                 const duration = Date.now() - startTime;
+                // A route that answers in its own wire format returns a web Response.
+                if (isWebResponse(result)) {
+                    const raw = await readWebResponse(result);
+                    this.emit("response", {
+                        requestId,
+                        statusCode: raw.status,
+                        duration,
+                        timestamp: new Date(),
+                    });
+                    for (const [key, value] of Object.entries({
+                        ...ctx.responseHeaders,
+                        ...raw.headers,
+                    })) {
+                        res.setHeader(key, value);
+                    }
+                    res.status(raw.status).send(raw.body);
+                    return;
+                }
                 // Check if result is an error response
                 if (isErrorResponse(result)) {
                     const statusCode = result.httpStatus ?? 500;
@@ -239,21 +268,29 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         this.errorHandlerRegistered = true;
         this.app.use((error, req, res, _next) => {
             const requestId = req.headers["x-request-id"];
-            logger.error("[ExpressAdapter] Request error", {
-                requestId,
-                error: error.message,
-                stack: error.stack,
-            });
-            this.emit("error", {
+            this.logRequestError("ExpressAdapter", requestId, error);
+            this.emitRequestError({
                 requestId,
                 error,
                 timestamp: new Date(),
             });
             // Use dynamic status code from ServerAdapterError if available
             const isServerAdapterError = error instanceof ServerAdapterError;
-            const statusCode = isServerAdapterError ? error.getHttpStatus() : 500;
-            const errorCode = isServerAdapterError ? error.code : "INTERNAL_ERROR";
-            const errorMessage = isServerAdapterError
+            // body-parser marks an over-limit body; it is the client's error.
+            const tooLarge = !isServerAdapterError &&
+                "type" in error &&
+                error.type === "entity.too.large";
+            const statusCode = isServerAdapterError
+                ? error.getHttpStatus()
+                : tooLarge
+                    ? 413
+                    : 500;
+            const errorCode = isServerAdapterError
+                ? error.code
+                : tooLarge
+                    ? "PAYLOAD_TOO_LARGE"
+                    : "INTERNAL_ERROR";
+            const errorMessage = isServerAdapterError || tooLarge
                 ? error.message
                 : "An internal error occurred";
             res.status(statusCode).json({
@@ -493,4 +530,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
     getFrameworkInstance() {
         return this.app;
     }
+    getNativeServer() {
+        return this.server;
+    }
 }

package/dist/server/adapters/fastifyAdapter.d.ts

@@ -67,4 +67,5 @@ export declare class FastifyServerAdapter extends BaseServerAdapter {
      * Get the Fastify instance
      */
     getFrameworkInstance(): unknown;
+    getNativeServer(): unknown;
 }

package/dist/server/adapters/fastifyAdapter.js

@@ -4,10 +4,11 @@
  * Fastify is known for its high performance and low overhead
  */
 import { logger } from "../../utils/logger.js";
-import { AlreadyRunningError, ServerStartError, ServerStopError, wrapError, } from "../errors.js";
+import { AlreadyRunningError, ServerAdapterError, ServerStartError, ServerStopError, wrapError, } from "../errors.js";
 import { withTimeout } from "../../utils/errorHandling.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import { isErrorResponse } from "../utils/validation.js";
+import { isRawBodyContentType, isWebResponse, readWebResponse, } from "../utils/rawBody.js";
 /**
  * Fastify-specific server adapter
  * Provides high-performance HTTP server with schema validation
@@ -46,11 +47,25 @@ export class FastifyServerAdapter extends BaseServerAdapter {
             genReqId: () => this.generateRequestId(),
             bodyLimit: this.parseBodyLimit(this.config.bodyParser.maxSize),
         });
+        // 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) => {
+                done(null, isRawBodyContentType(request.headers["content-type"])
+                    ? body
+                    : undefined);
+            });
+        }
         // Register CORS plugin if enabled
         if (this.config.cors.enabled) {
             const corsModule = await this.importFrameworkDependency("@fastify/cors", "Fastify");
             await this.app.register(corsModule.default, {
-                origin: this.config.cors.origins,
+                // A list is matched literally, so the default `["*"]` would match
+                // nothing; the wildcard has to be the string "*" (Koa handles it in
+                // its origin callback).
+                origin: this.config.cors.origins.includes("*")
+                    ? "*"
+                    : this.config.cors.origins,
                 methods: this.config.cors.methods,
                 allowedHeaders: this.config.cors.headers,
                 credentials: this.config.cors.credentials,
@@ -91,17 +106,23 @@ export class FastifyServerAdapter extends BaseServerAdapter {
         // Global error handler
         this.app.setErrorHandler((error, request, reply) => {
             const requestId = request.id;
-            logger.error("[FastifyAdapter] Request error", {
-                requestId,
-                error: error.message,
-                stack: error.stack,
-            });
-            this.emit("error", {
+            this.logRequestError("FastifyAdapter", requestId, error);
+            this.emitRequestError({
                 requestId,
                 error,
                 timestamp: new Date(),
             });
             // Handle different error types
+            if (error instanceof ServerAdapterError) {
+                reply.status(error.getHttpStatus()).send({
+                    error: { code: error.code, message: error.message },
+                    metadata: {
+                        requestId,
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+                return;
+            }
             if (error.statusCode) {
                 reply.status(error.statusCode).send({
                     error: {
@@ -229,6 +250,24 @@ export class FastifyServerAdapter extends BaseServerAdapter {
                 // Execute handler
                 const result = await route.handler(ctx);
                 const duration = Date.now() - startTime;
+                // A route that answers in its own wire format returns a web Response.
+                if (isWebResponse(result)) {
+                    const raw = await readWebResponse(result);
+                    this.emit("response", {
+                        requestId,
+                        statusCode: raw.status,
+                        duration,
+                        timestamp: new Date(),
+                    });
+                    for (const [key, value] of Object.entries({
+                        ...ctx.responseHeaders,
+                        ...raw.headers,
+                    })) {
+                        reply.header(key, value);
+                    }
+                    reply.status(raw.status);
+                    return reply.send(raw.body);
+                }
                 // Check if result is an error response
                 if (isErrorResponse(result)) {
                     const statusCode = result.httpStatus ?? 500;
@@ -479,4 +518,8 @@ export class FastifyServerAdapter extends BaseServerAdapter {
     getFrameworkInstance() {
         return this.app;
     }
+    getNativeServer() {
+        // Fastify owns its http.Server and exposes it as `app.server`.
+        return this.app?.server;
+    }
 }

package/dist/server/adapters/honoAdapter.d.ts

@@ -6,10 +6,6 @@
 import type { NeuroLink } from "../../neurolink.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import type { MiddlewareDefinition, RouteDefinition, ServerAdapterConfig } from "../../types/index.js";
-/**
- * Hono-specific server adapter
- * Supports multiple runtimes: Bun, Deno, Node.js
- */
 export declare class HonoServerAdapter extends BaseServerAdapter {
     private app;
     private server?;
@@ -75,6 +71,7 @@ export declare class HonoServerAdapter extends BaseServerAdapter {
      * Get the Hono app instance
      */
     getFrameworkInstance(): unknown;
+    getNativeServer(): unknown;
     private extractHeaders;
     private extractQuery;
     private extractBody;