@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/server/utils/validation.js

@@ -1,265 +0,0 @@
-/**
- * Request Validation Utilities
- * Provides Zod schemas and validation helpers for server routes
- */
-import { z } from "zod";
-// ============================================
-// Validation Schemas
-// ============================================
-/**
- * Agent execute request schema
- */
-export const AgentExecuteRequestSchema = z.object({
-    input: z.union([
-        z.string(),
-        z.object({
-            text: z.string(),
-            images: z.array(z.string()).optional(),
-            files: z.array(z.string()).optional(),
-        }),
-    ]),
-    provider: z.string().optional(),
-    model: z.string().optional(),
-    systemPrompt: z.string().optional(),
-    temperature: z.number().min(0).max(2).optional(),
-    maxTokens: z.number().positive().optional(),
-    tools: z.array(z.string()).optional(),
-    stream: z.boolean().optional(),
-    sessionId: z.string().optional(),
-    userId: z.string().optional(),
-});
-/**
- * Tool execute request schema
- */
-export const ToolExecuteRequestSchema = z.object({
-    name: z.string().min(1, "Tool name is required"),
-    arguments: z.record(z.string(), z.unknown()).default({}),
-    sessionId: z.string().optional(),
-    userId: z.string().optional(),
-});
-/**
- * Tool arguments schema (for direct tool execution)
- */
-export const ToolArgumentsSchema = z.record(z.string(), z.unknown());
-/**
- * Memory session ID parameter schema
- */
-export const SessionIdParamSchema = z.object({
-    sessionId: z.string().min(1, "Session ID is required"),
-});
-/**
- * MCP server name parameter schema
- */
-export const ServerNameParamSchema = z.object({
-    name: z.string().min(1, "Server name is required"),
-});
-/**
- * Tool name parameter schema
- */
-export const ToolNameParamSchema = z.object({
-    name: z.string().min(1, "Tool name is required"),
-});
-/**
- * Tool search query schema
- */
-export const ToolSearchQuerySchema = z.object({
-    q: z.string().optional(),
-    source: z.string().optional(),
-    limit: z
-        .string()
-        .transform((val) => parseInt(val, 10))
-        .pipe(z.number().positive().max(100))
-        .optional(),
-});
-/**
- * Generic ID parameter schema (for session endpoints using :id)
- */
-export const IdParamSchema = z.object({
-    id: z.string().min(1, "Session ID is required"),
-});
-/**
- * Sessions list query schema (with optional pagination and filtering)
- */
-export const SessionsListQuerySchema = z.object({
-    userId: z.string().optional(),
-    limit: z
-        .string()
-        .transform((val) => parseInt(val, 10))
-        .pipe(z.number().positive().max(100))
-        .optional(),
-    offset: z
-        .string()
-        .transform((val) => parseInt(val, 10))
-        .pipe(z.number().nonnegative())
-        .optional(),
-});
-/**
- * Session messages query schema (for pagination)
- */
-export const SessionMessagesQuerySchema = z.object({
-    limit: z
-        .string()
-        .transform((val) => parseInt(val, 10))
-        .pipe(z.number().positive().max(100))
-        .optional(),
-    offset: z
-        .string()
-        .transform((val) => parseInt(val, 10))
-        .pipe(z.number().nonnegative())
-        .optional(),
-});
-/**
- * Embed request schema (single text)
- */
-export const EmbedRequestSchema = z.object({
-    text: z.string().min(1, "Text is required"),
-    provider: z.string().optional(),
-    model: z.string().optional(),
-});
-/**
- * Embed many request schema (batch texts)
- */
-export const EmbedManyRequestSchema = z.object({
-    texts: z
-        .array(z.string().min(1))
-        .min(1, "At least one text is required")
-        .max(2048, "Maximum 2048 texts per batch"),
-    provider: z.string().optional(),
-    model: z.string().optional(),
-});
-/**
- * Skill create request schema
- */
-export const SkillCreateRequestSchema = z.object({
-    name: z.string().min(1, "Name is required"),
-    displayName: z.string().optional(),
-    description: z.string().min(1, "Description is required"),
-    instructions: z.string().min(1, "Instructions are required"),
-    tags: z.array(z.string()).optional(),
-    scope: z.enum(["global", "scoped"]).optional(),
-    scopeIds: z.array(z.string()).optional(),
-    requestedBy: z.string().optional(),
-});
-/**
- * Skill update request schema — all fields optional (patch semantics)
- */
-export const SkillUpdateRequestSchema = SkillCreateRequestSchema.partial();
-// ============================================
-// Error Response Type Guards / Helpers
-// ============================================
-/**
- * Type guard to check if a value is an ErrorResponse
- */
-export function isErrorResponse(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "error" in value &&
-        typeof value.error === "object" &&
-        value.error !== null &&
-        "code" in value.error &&
-        "message" in value.error);
-}
-/**
- * Get default HTTP status code based on error code
- */
-function getDefaultHttpStatus(code) {
-    const statusMap = {
-        VALIDATION_ERROR: 400,
-        SCHEMA_ERROR: 400,
-        TOOL_NOT_FOUND: 404,
-        SERVER_NOT_FOUND: 404,
-        SESSION_NOT_FOUND: 404,
-        NOT_FOUND: 404,
-        AUTH_REQUIRED: 401,
-        AUTH_INVALID: 401,
-        FORBIDDEN: 403,
-        RATE_LIMIT_EXCEEDED: 429,
-        MCP_UNAVAILABLE: 503,
-        MEMORY_UNAVAILABLE: 503,
-        SKILLS_UNAVAILABLE: 503,
-        EXECUTION_FAILED: 500,
-        INTERNAL_ERROR: 500,
-    };
-    return statusMap[code] ?? 500;
-}
-// ============================================
-// Validation Helpers
-// ============================================
-/**
- * Create a standardized error response
- */
-export function createErrorResponse(code, message, details, requestId, httpStatus) {
-    return {
-        error: {
-            code,
-            message,
-            details,
-        },
-        metadata: {
-            timestamp: new Date().toISOString(),
-            requestId,
-        },
-        httpStatus: httpStatus ?? getDefaultHttpStatus(code),
-    };
-}
-/**
- * Validate request body against a Zod schema
- */
-export function validateRequest(schema, data, requestId) {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-        return {
-            success: false,
-            error: createErrorResponse("VALIDATION_ERROR", "Invalid request body", result.error.issues.map((issue) => ({
-                path: issue.path.join("."),
-                message: issue.message,
-                code: issue.code,
-            })), requestId),
-        };
-    }
-    return {
-        success: true,
-        data: result.data,
-    };
-}
-/**
- * Validate query parameters against a Zod schema
- */
-export function validateQuery(schema, query, requestId) {
-    const result = schema.safeParse(query);
-    if (!result.success) {
-        return {
-            success: false,
-            error: createErrorResponse("VALIDATION_ERROR", "Invalid query parameters", result.error.issues.map((issue) => ({
-                path: issue.path.join("."),
-                message: issue.message,
-                code: issue.code,
-            })), requestId),
-        };
-    }
-    return {
-        success: true,
-        data: result.data,
-    };
-}
-/**
- * Validate path parameters against a Zod schema
- */
-export function validateParams(schema, params, requestId) {
-    const result = schema.safeParse(params);
-    if (!result.success) {
-        return {
-            success: false,
-            error: createErrorResponse("VALIDATION_ERROR", "Invalid path parameters", result.error.issues.map((issue) => ({
-                path: issue.path.join("."),
-                message: issue.message,
-                code: issue.code,
-            })), requestId),
-        };
-    }
-    return {
-        success: true,
-        data: result.data,
-    };
-}
-//# sourceMappingURL=validation.js.map

package/dist/lib/server/voice/frameBus.d.ts

@@ -1,8 +0,0 @@
-import type { Frame } from "../../types/index.js";
-export declare class FrameBus {
-    private handlers;
-    subscribe<T extends Frame["type"]>(type: T, fn: (frame: Extract<Frame, {
-        type: T;
-    }>) => void): void;
-    publish(frame: Frame): void;
-}

package/dist/lib/server/voice/frameBus.js

@@ -1,25 +0,0 @@
-import { logger } from "../../utils/logger.js";
-export class FrameBus {
-    handlers = {};
-    subscribe(type, fn) {
-        if (!this.handlers[type]) {
-            this.handlers[type] = [];
-        }
-        this.handlers[type].push(fn);
-    }
-    publish(frame) {
-        const subs = this.handlers[frame.type];
-        if (!subs) {
-            return;
-        }
-        for (const fn of subs) {
-            try {
-                fn(frame);
-            }
-            catch (err) {
-                logger.error(`[FrameBus] Subscriber threw on ${frame.type}:`, err);
-            }
-        }
-    }
-}
-//# sourceMappingURL=frameBus.js.map

package/dist/lib/server/voice/tokenCompare.d.ts

@@ -1,14 +0,0 @@
-/**
- * Constant-time bearer-token comparison.
- *
- * Bug 2 mitigation: a normal `===` compare on bearer tokens leaks the token
- * length and the position of the first mismatching byte through timing
- * differences, which is reachable when the voice server is bound publicly
- * (`VOICE_SERVER_ALLOW_PUBLIC=1`).
- *
- * Returns `false` for any comparison whose lengths differ — this avoids the
- * `RangeError` that `crypto.timingSafeEqual` throws on mismatched buffers
- * while still preserving the constant-time property for equal-length inputs
- * (which is the only case an attacker can probe).
- */
-export declare function timingSafeEqualString(provided: string, expected: string): boolean;

package/dist/lib/server/voice/tokenCompare.js

@@ -1,23 +0,0 @@
-import crypto from "crypto";
-/**
- * Constant-time bearer-token comparison.
- *
- * Bug 2 mitigation: a normal `===` compare on bearer tokens leaks the token
- * length and the position of the first mismatching byte through timing
- * differences, which is reachable when the voice server is bound publicly
- * (`VOICE_SERVER_ALLOW_PUBLIC=1`).
- *
- * Returns `false` for any comparison whose lengths differ — this avoids the
- * `RangeError` that `crypto.timingSafeEqual` throws on mismatched buffers
- * while still preserving the constant-time property for equal-length inputs
- * (which is the only case an attacker can probe).
- */
-export function timingSafeEqualString(provided, expected) {
-    const providedBuf = Buffer.from(provided, "utf8");
-    const expectedBuf = Buffer.from(expected, "utf8");
-    if (providedBuf.length !== expectedBuf.length) {
-        return false;
-    }
-    return crypto.timingSafeEqual(providedBuf, expectedBuf);
-}
-//# sourceMappingURL=tokenCompare.js.map

package/dist/lib/server/voice/turnManager.d.ts

@@ -1,15 +0,0 @@
-import type { FrameBus } from "./frameBus.js";
-export declare enum TurnState {
-    IDLE = 0,
-    USER_SPEAKING = 1,
-    PROCESSING = 2,
-    ASSISTANT_SPEAKING = 3
-}
-export declare class TurnManager {
-    state: TurnState;
-    constructor(bus: FrameBus);
-    private onVadStart;
-    private onVadStop;
-    assistantSpeaking(): void;
-    reset(): void;
-}

package/dist/lib/server/voice/turnManager.js

@@ -1,36 +0,0 @@
-export var TurnState;
-(function (TurnState) {
-    TurnState[TurnState["IDLE"] = 0] = "IDLE";
-    TurnState[TurnState["USER_SPEAKING"] = 1] = "USER_SPEAKING";
-    TurnState[TurnState["PROCESSING"] = 2] = "PROCESSING";
-    TurnState[TurnState["ASSISTANT_SPEAKING"] = 3] = "ASSISTANT_SPEAKING";
-})(TurnState || (TurnState = {}));
-export class TurnManager {
-    state = TurnState.IDLE;
-    constructor(bus) {
-        bus.subscribe("vad_start", () => this.onVadStart());
-        bus.subscribe("vad_stop", () => this.onVadStop());
-    }
-    onVadStart() {
-        // Only update state if TTS is NOT playing. During ASSISTANT_SPEAKING, the
-        // barge-in interrupt is triggered by Soniox non-final tokens — which arrive
-        // after a network round-trip. If we let VAD immediately flip state to
-        // USER_SPEAKING, the state check in handleSonioxMessage fails and the
-        // interrupt never fires.
-        if (this.state !== TurnState.ASSISTANT_SPEAKING) {
-            this.state = TurnState.USER_SPEAKING;
-        }
-    }
-    onVadStop() {
-        if (this.state === TurnState.USER_SPEAKING) {
-            this.state = TurnState.PROCESSING;
-        }
-    }
-    assistantSpeaking() {
-        this.state = TurnState.ASSISTANT_SPEAKING;
-    }
-    reset() {
-        this.state = TurnState.IDLE;
-    }
-}
-//# sourceMappingURL=turnManager.js.map

package/dist/lib/server/voice/voiceServerApp.d.ts

@@ -1 +0,0 @@
-export declare function startVoiceServer(port?: number): Promise<void>;

package/dist/lib/server/voice/voiceServerApp.js

@@ -1,177 +0,0 @@
-import express from "express";
-import fs from "fs";
-import http from "http";
-import path from "path";
-import { fileURLToPath } from "url";
-import { setupWebSocket } from "./voiceWebSocketHandler.js";
-import { timingSafeEqualString } from "./tokenCompare.js";
-import { NeuroLink } from "../../neurolink.js";
-import { logger } from "../../utils/logger.js";
-import { withTimeout } from "../../utils/async/withTimeout.js";
-import { getCartesiaWsUrl } from "../../adapters/tts/cartesiaHandler.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Resolve the public/ directory containing static assets.
- * The CLI build (tsc) only emits .ts → .js and does NOT copy non-TS assets,
- * so __dirname/public may not exist when running from dist/.
- * Fall back to the original source path in that case.
- */
-function resolvePublicPath() {
-    const compiled = path.join(__dirname, "public");
-    if (fs.existsSync(compiled)) {
-        return compiled;
-    }
-    // Resolve from project root → src/lib/server/voice/public
-    const source = path.resolve(__dirname, "../../../../src/lib/server/voice/public");
-    if (fs.existsSync(source)) {
-        return source;
-    }
-    return compiled; // let express.static handle the 404
-}
-export async function startVoiceServer(port = 3000) {
-    const app = express();
-    // NEW11: refuse to bind to non-loopback interfaces unless the operator
-    // has explicitly opted in. The voice server has minimal hardening and
-    // exposing it publicly without a token leaks Soniox / Cartesia / LLM
-    // credit usage to anyone who can reach the listener.
-    const allowPublic = process.env.VOICE_SERVER_ALLOW_PUBLIC === "1";
-    const host = allowPublic
-        ? (process.env.VOICE_SERVER_HOST ?? "0.0.0.0")
-        : "127.0.0.1";
-    // NEW11: optional shared-secret bearer token for both HTTP and WebSocket
-    // upgrade. When VOICE_SERVER_AUTH_TOKEN is set, every HTTP request must
-    // carry `Authorization: Bearer <token>`. The WS upgrade additionally
-    // accepts `?token=<token>` because browser WebSocket constructors cannot
-    // set custom headers — see voiceWebSocketHandler.verifyClient. HTTP routes
-    // intentionally reject `?token=` (would leak via Referer + access logs).
-    const authToken = process.env.VOICE_SERVER_AUTH_TOKEN;
-    /* ---------- BODY LIMITS + AUTH ---------- */
-    // NEW11: cap JSON / urlencoded body to 100kb. Express's default is 100kb
-    // for json() but only when explicitly registered; without this any future
-    // body parser would default to whatever its own limit is.
-    app.use(express.json({ limit: "100kb" }));
-    app.use(express.urlencoded({ limit: "100kb", extended: false }));
-    // NEW11: minimal HTTP auth middleware. Skips when no token is configured
-    // (back-compat — local-only dev keeps working). Skips for /health so
-    // load-balancers can probe without credentials.
-    if (authToken) {
-        app.use((req, res, next) => {
-            if (req.path === "/health") {
-                return next();
-            }
-            const header = req.header("authorization");
-            // Bug 3 fix: HTTP routes only accept the bearer header. The `?token=`
-            // fallback exists only on the WS upgrade where the browser API cannot
-            // attach headers — using it on regular HTTP would leak credentials via
-            // Referer headers, browser history, server access logs, and proxies.
-            const provided = header?.startsWith("Bearer ")
-                ? header.slice(7)
-                : undefined;
-            if (!provided || !timingSafeEqualString(provided, authToken)) {
-                res.status(401).json({ error: "Unauthorized" });
-                return;
-            }
-            next();
-        });
-    }
-    /* ---------- STATIC FILES ---------- */
-    const publicPath = resolvePublicPath();
-    logger.info("[SERVER] Serving static from:", publicPath);
-    app.use(express.static(publicPath));
-    app.get("/", (_, res) => {
-        res.sendFile(path.join(publicPath, "index.html"));
-    });
-    /* ---------- HEALTH CHECK ---------- */
-    app.get("/health", (_, res) => {
-        res.json({ status: "ok" });
-    });
-    /* ---------- ERROR HANDLER ---------- */
-    // NEW11: global Express error handler so synchronous and async errors are
-    // caught instead of crashing the process or leaking stack traces.
-    app.use((err, _req, res, _next) => {
-        logger.error(`[SERVER] Unhandled error: ${err instanceof Error ? err.message : String(err)}`);
-        if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    const server = http.createServer(app);
-    /* ---------- WS ---------- */
-    // NEW11: pass the auth token + allow-public flag through to the WS handler
-    // so it can verify clients on upgrade and apply maxPayload caps.
-    setupWebSocket(server, { authToken, maxPayload: 1_048_576 });
-    /* ---------- START ---------- */
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(port, host, () => {
-            server.removeListener("error", reject);
-            const exposure = allowPublic
-                ? `bound publicly on ${host}:${port} (VOICE_SERVER_ALLOW_PUBLIC=1)`
-                : `bound to loopback ${host}:${port} (set VOICE_SERVER_ALLOW_PUBLIC=1 to expose externally)`;
-            logger.info(`[SERVER] Voice server running — ${exposure}${authToken ? " (auth required)" : " (no auth — token via VOICE_SERVER_AUTH_TOKEN recommended)"}`);
-            resolve();
-        });
-    });
-    /* ---------- WARMUP ---------- */
-    // Pre-warm NeuroLink + Azure on startup so the first real user request isn't
-    // slow. NeuroLink's MCP init + Azure's connection pool both have cold-start
-    // overhead that shows up as 3-4s on the very first call. We also open and
-    // immediately close a Cartesia WS to prime the TLS handshake.
-    warmup().catch((err) => {
-        logger.warn("[WARMUP] Failed (non-fatal):", err.message);
-    });
-}
-async function warmup() {
-    const t = Date.now();
-    logger.info("[WARMUP] Warming up LLM + TTS...");
-    const neurolink = new NeuroLink();
-    const provider = process.env.VOICE_LLM_PROVIDER ?? "azure";
-    const model = process.env.VOICE_LLM_MODEL ?? "gpt-4o-automatic";
-    try {
-        const result = await withTimeout(neurolink.stream({
-            provider,
-            model,
-            input: { text: "hi" },
-            maxTokens: 3,
-            disableTools: true,
-            enableAnalytics: false,
-            enableEvaluation: false,
-        }), 15000, "LLM warmup timed out");
-        // Drain the stream so the connection is fully exercised.
-        for await (const _chunk of result.stream) {
-            /* drain */
-        }
-        logger.info(`[WARMUP] LLM warmup done in ${Date.now() - t}ms`);
-    }
-    catch (err) {
-        logger.warn("[WARMUP] LLM warmup failed (non-fatal):", err.message);
-    }
-    // Cartesia TLS warmup — open WS, wait for connect, then close.
-    try {
-        const { default: WebSocket } = await import("ws");
-        const apiKey = process.env.CARTESIA_API_KEY;
-        await new Promise((resolve) => {
-            const ws = new WebSocket(getCartesiaWsUrl(), {
-                headers: apiKey ? { "X-API-Key": apiKey } : undefined,
-            });
-            const timeout = setTimeout(() => {
-                ws.terminate();
-                resolve(); // non-fatal, just move on
-            }, 5000);
-            ws.once("open", () => {
-                clearTimeout(timeout);
-                ws.close();
-                resolve();
-            });
-            ws.once("error", () => {
-                clearTimeout(timeout);
-                resolve(); // non-fatal
-            });
-        });
-        logger.info(`[WARMUP] Cartesia warmup done in ${Date.now() - t}ms`);
-    }
-    catch {
-        // non-fatal
-    }
-}
-//# sourceMappingURL=voiceServerApp.js.map

package/dist/lib/server/voice/voiceWebSocketHandler.d.ts

@@ -1,24 +0,0 @@
-import type { Server as HttpServer } from "http";
-/**
- * Voice-server-mode environment configuration.
- *
- * @deprecated NEW12 — this used to mutate `process.env.NEUROLINK_DISABLE_MCP_TOOLS`
- * which is process-wide. That broke any embedder that called this function in
- * a process which ALSO used NeuroLink for non-voice work. The disable-tools
- * intent is now passed explicitly via `disableTools: true` on every NeuroLink
- * `generate()` / `stream()` call inside this server (see line ~167). Calling
- * this function is now a no-op kept for backwards compatibility.
- */
-export declare function configureVoiceServerEnvironment(): void;
-/**
- * Returns a copy of an outbound Soniox payload with the API key redacted.
- *
- * Use this whenever debug logging the auth frame — never JSON.stringify the
- * raw object. (C3 mitigation: prevents the Soniox API key from leaking into
- * any aggregated log sink even if a future debug statement serialises the
- * outbound payload.)
- */
-export declare function redactSonioxAuth<T extends {
-    api_key?: string;
-}>(payload: T): T;
-export declare function setupWebSocket(server: HttpServer, options?: import("../../types/index.js").ServerVoiceWebSocketOptions): void;