@juspay/neurolink 11.12.0 → 11.13.1

package/dist/lib/server/streaming/index.js

@@ -1,17 +0,0 @@
-/**
- * Streaming Module
- * Exports for data stream protocol and streaming utilities
- */
-export { 
-// Types
-// Writer
-createDataStreamWriter, 
-// Response
-DataStreamResponse, createDataStreamResponse, 
-// Helpers
-pipeAsyncIterableToDataStream, createSSEHeaders, createNDJSONHeaders, 
-// SSE Event Formatting
-formatSSEEvent, 
-// WebStreamWriter (Legacy Compatibility)
-BaseDataStreamWriter, WebStreamWriter, } from "./dataStream.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/server/utils/redaction.d.ts

@@ -1,68 +0,0 @@
-import type { RedactionConfig, DataStreamEvent } from "../../types/index.js";
-/**
- * Redact sensitive data from a stream chunk.
- *
- * IMPORTANT: Redaction is DISABLED by default. You must set `config.enabled = true`
- * to enable redaction. This is a security feature that requires explicit opt-in.
- *
- * @param chunk - The stream chunk to redact
- * @param config - Redaction configuration (enabled: false by default)
- * @returns The redacted chunk with sensitive data removed, or original if disabled
- *
- * @example
- * ```typescript
- * // Redaction disabled by default - returns chunk unchanged
- * const unchanged = redactStreamChunk(chunk);
- *
- * // Enable redaction explicitly
- * const redacted = redactStreamChunk(chunk, { enabled: true });
- * // Sensitive fields replaced with "[REDACTED]"
- * ```
- *
- * @example
- * ```typescript
- * // With custom configuration (must enable first)
- * const redacted = redactStreamChunk(chunk, {
- *   enabled: true,
- *   additionalFields: ["customSecret"],
- *   preserveFields: ["result"], // Don't redact result
- * });
- * ```
- */
-export declare function redactStreamChunk(chunk: DataStreamEvent, config?: RedactionConfig): DataStreamEvent;
-/**
- * Create a redaction transform function for streams.
- *
- * IMPORTANT: Redaction is DISABLED by default. You must set `config.enabled = true`
- * to enable redaction. If not enabled, the returned function passes chunks through unchanged.
- *
- * @param config - Redaction configuration
- * @returns A transform function for stream chunks
- *
- * @example
- * ```typescript
- * // Redaction disabled - chunks pass through unchanged
- * const redactor = createStreamRedactor();
- * const unchanged = redactor(chunk); // Returns original chunk
- *
- * // Enable redaction
- * const redactor = createStreamRedactor({ enabled: true });
- * const redactedStream = stream.pipeThrough(new TransformStream({
- *   transform: (chunk, controller) => {
- *     controller.enqueue(redactor(chunk));
- *   }
- * }));
- * ```
- *
- * @example
- * ```typescript
- * // With custom options
- * const redactor = createStreamRedactor({
- *   enabled: true,
- *   redactToolArgs: true,
- *   redactToolResults: true,
- *   additionalFields: ["internalId"],
- * });
- * ```
- */
-export declare function createStreamRedactor(config?: RedactionConfig): <T>(chunk: T) => T;

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

@@ -1,321 +0,0 @@
-/**
- * Default fields to redact from stream chunks
- */
-const DEFAULT_REDACTED_FIELDS = [
-    "request",
-    "args",
-    "result",
-    "apiKey",
-    "token",
-    "authorization",
-    "credentials",
-    "password",
-    "secret",
-];
-/**
- * Default redaction placeholder
- */
-const DEFAULT_PLACEHOLDER = "[REDACTED]";
-/**
- * Maximum recursion depth for redactObject
- */
-const MAX_REDACTION_DEPTH = 10;
-/**
- * Redact sensitive data from a stream chunk.
- *
- * IMPORTANT: Redaction is DISABLED by default. You must set `config.enabled = true`
- * to enable redaction. This is a security feature that requires explicit opt-in.
- *
- * @param chunk - The stream chunk to redact
- * @param config - Redaction configuration (enabled: false by default)
- * @returns The redacted chunk with sensitive data removed, or original if disabled
- *
- * @example
- * ```typescript
- * // Redaction disabled by default - returns chunk unchanged
- * const unchanged = redactStreamChunk(chunk);
- *
- * // Enable redaction explicitly
- * const redacted = redactStreamChunk(chunk, { enabled: true });
- * // Sensitive fields replaced with "[REDACTED]"
- * ```
- *
- * @example
- * ```typescript
- * // With custom configuration (must enable first)
- * const redacted = redactStreamChunk(chunk, {
- *   enabled: true,
- *   additionalFields: ["customSecret"],
- *   preserveFields: ["result"], // Don't redact result
- * });
- * ```
- */
-export function redactStreamChunk(chunk, config) {
-    // CRITICAL: Redaction is DISABLED by default
-    // Must explicitly enable with config.enabled = true
-    if (!config?.enabled) {
-        return chunk;
-    }
-    if (!chunk || typeof chunk !== "object") {
-        return chunk;
-    }
-    const placeholder = config?.placeholder ?? DEFAULT_PLACEHOLDER;
-    const redactedFields = new Set([
-        ...DEFAULT_REDACTED_FIELDS,
-        ...(config?.additionalFields ?? []),
-    ]);
-    // Remove preserved fields from redaction set
-    if (config?.preserveFields) {
-        for (const field of config.preserveFields) {
-            redactedFields.delete(field);
-        }
-    }
-    return redactChunkByType(chunk, redactedFields, placeholder, config);
-}
-/**
- * Redact chunk based on its type
- */
-function redactChunkByType(chunk, redactedFields, placeholder, config) {
-    const typedChunk = chunk;
-    const chunkType = typedChunk.type;
-    switch (chunkType) {
-        case "step-start":
-            return redactStepStart(chunk, redactedFields, placeholder);
-        case "tool-call":
-            return redactToolCall(chunk, redactedFields, placeholder, config);
-        case "tool-result":
-            return redactToolResult(chunk, redactedFields, placeholder, config);
-        case "error":
-            return redactError(chunk, redactedFields, placeholder);
-        default:
-            return redactGenericChunk(typedChunk, redactedFields, placeholder);
-    }
-}
-/**
- * Redact step-start chunks
- */
-function redactStepStart(chunk, redactedFields, placeholder) {
-    if (!hasPayload(chunk)) {
-        return chunk;
-    }
-    const { payload, ...rest } = chunk;
-    const redactedPayload = redactObject(payload, redactedFields, placeholder, 0);
-    const redacted = {
-        ...rest,
-        payload: redactedPayload,
-    };
-    return redacted;
-}
-/**
- * Redact tool-call chunks
- */
-function redactToolCall(chunk, redactedFields, placeholder, config) {
-    // Handle chunks with payload structure
-    if (hasPayload(chunk)) {
-        const { payload, ...rest } = chunk;
-        // Redact tool arguments if configured
-        if (payload.toolCall && typeof payload.toolCall === "object") {
-            const toolCall = payload.toolCall;
-            const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
-            const redacted = {
-                ...rest,
-                payload: {
-                    ...payload,
-                    toolCall: {
-                        ...toolCall,
-                        args: redactArgs ? placeholder : toolCall.args,
-                    },
-                },
-            };
-            return redacted;
-        }
-        const redacted = {
-            ...rest,
-            payload: redactObject(payload, redactedFields, placeholder, 0),
-        };
-        return redacted;
-    }
-    // Handle chunks with data structure (DataStreamEvent format)
-    if (hasData(chunk)) {
-        const { data, ...rest } = chunk;
-        const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
-        // Check for arguments field in data
-        if ("arguments" in data && redactArgs) {
-            return {
-                ...rest,
-                data: {
-                    ...data,
-                    arguments: placeholder,
-                },
-            };
-        }
-        return {
-            ...rest,
-            data: redactObject(data, redactedFields, placeholder, 0),
-        };
-    }
-    return chunk;
-}
-/**
- * Redact tool-result chunks
- */
-function redactToolResult(chunk, redactedFields, placeholder, config) {
-    const redactResult = config?.redactToolResults !== false && redactedFields.has("result");
-    // Handle chunks with payload structure
-    if (hasPayload(chunk)) {
-        const { payload, ...rest } = chunk;
-        const redacted = {
-            ...rest,
-            payload: {
-                ...payload,
-                result: redactResult ? placeholder : payload.result,
-            },
-        };
-        return redacted;
-    }
-    // Handle chunks with data structure (DataStreamEvent format)
-    if (hasData(chunk)) {
-        const { data, ...rest } = chunk;
-        return {
-            ...rest,
-            data: {
-                ...data,
-                result: redactResult ? placeholder : data.result,
-            },
-        };
-    }
-    return chunk;
-}
-/**
- * Redact error chunks (remove stack traces in production)
- */
-function redactError(chunk, redactedFields, placeholder) {
-    const isProduction = process.env.NODE_ENV === "production";
-    // Handle chunks with data structure (DataStreamEvent format)
-    if (hasData(chunk)) {
-        const { data, ...rest } = chunk;
-        const { stack, ...dataRest } = data;
-        return {
-            ...rest,
-            data: {
-                ...redactObject(dataRest, redactedFields, placeholder, 0),
-                ...(isProduction ? {} : { stack }),
-            },
-        };
-    }
-    // Handle direct chunk with stack
-    const chunkRecord = chunk;
-    const { stack, ...restChunk } = chunkRecord;
-    const redactedRest = redactObject(restChunk, redactedFields, placeholder, 0);
-    return {
-        ...redactedRest,
-        type: "error",
-        ...(isProduction ? {} : { stack }),
-    };
-}
-/**
- * Redact generic chunks by scanning all fields
- */
-function redactGenericChunk(chunk, redactedFields, placeholder) {
-    return redactObject(chunk, redactedFields, placeholder, 0);
-}
-/**
- * Recursively redact sensitive fields from an object.
- *
- * @param obj - Object to redact
- * @param redactedFields - Set of field names to redact (case-insensitive matching)
- * @param placeholder - Replacement value for redacted fields
- * @param depth - Current recursion depth
- * @returns Object with sensitive fields redacted
- */
-function redactObject(obj, redactedFields, placeholder, depth) {
-    // Prevent infinite recursion
-    if (depth > MAX_REDACTION_DEPTH) {
-        return obj;
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        // Case-insensitive field name matching
-        const shouldRedact = redactedFields.has(key.toLowerCase());
-        if (shouldRedact) {
-            result[key] = placeholder;
-        }
-        else if (value && typeof value === "object" && !Array.isArray(value)) {
-            result[key] = redactObject(value, redactedFields, placeholder, depth + 1);
-        }
-        else if (Array.isArray(value)) {
-            result[key] = value.map((item) => {
-                if (item && typeof item === "object") {
-                    return redactObject(item, redactedFields, placeholder, depth + 1);
-                }
-                return item;
-            });
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-/**
- * Type guard for chunks with payload
- */
-function hasPayload(chunk) {
-    const record = chunk;
-    return ("payload" in record &&
-        record.payload !== null &&
-        typeof record.payload === "object");
-}
-/**
- * Type guard for chunks with data (DataStreamEvent format)
- */
-function hasData(chunk) {
-    return ("data" in chunk && chunk.data !== null && typeof chunk.data === "object");
-}
-/**
- * Create a redaction transform function for streams.
- *
- * IMPORTANT: Redaction is DISABLED by default. You must set `config.enabled = true`
- * to enable redaction. If not enabled, the returned function passes chunks through unchanged.
- *
- * @param config - Redaction configuration
- * @returns A transform function for stream chunks
- *
- * @example
- * ```typescript
- * // Redaction disabled - chunks pass through unchanged
- * const redactor = createStreamRedactor();
- * const unchanged = redactor(chunk); // Returns original chunk
- *
- * // Enable redaction
- * const redactor = createStreamRedactor({ enabled: true });
- * const redactedStream = stream.pipeThrough(new TransformStream({
- *   transform: (chunk, controller) => {
- *     controller.enqueue(redactor(chunk));
- *   }
- * }));
- * ```
- *
- * @example
- * ```typescript
- * // With custom options
- * const redactor = createStreamRedactor({
- *   enabled: true,
- *   redactToolArgs: true,
- *   redactToolResults: true,
- *   additionalFields: ["internalId"],
- * });
- * ```
- */
-export function createStreamRedactor(config) {
-    return (chunk) => {
-        // When redaction is disabled (default), return chunk unchanged
-        // This allows the redactor to be used with any chunk type as a no-op
-        if (!config?.enabled) {
-            return chunk;
-        }
-        // When enabled, apply redaction (works with any object-based chunk)
-        return redactStreamChunk(chunk, config);
-    };
-}
-//# sourceMappingURL=redaction.js.map

package/dist/lib/server/utils/validation.d.ts

@@ -1,153 +0,0 @@
-/**
- * Request Validation Utilities
- * Provides Zod schemas and validation helpers for server routes
- */
-import { z } from "zod";
-import type { ErrorResponse, ServerValidationResult } from "../../types/index.js";
-/**
- * Agent execute request schema
- */
-export declare const AgentExecuteRequestSchema: z.ZodObject<{
-    input: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        text: z.ZodString;
-        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>]>;
-    provider: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-    systemPrompt: z.ZodOptional<z.ZodString>;
-    temperature: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    stream: z.ZodOptional<z.ZodBoolean>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Tool execute request schema
- */
-export declare const ToolExecuteRequestSchema: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Tool arguments schema (for direct tool execution)
- */
-export declare const ToolArgumentsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-/**
- * Memory session ID parameter schema
- */
-export declare const SessionIdParamSchema: z.ZodObject<{
-    sessionId: z.ZodString;
-}, z.core.$strip>;
-/**
- * MCP server name parameter schema
- */
-export declare const ServerNameParamSchema: z.ZodObject<{
-    name: z.ZodString;
-}, z.core.$strip>;
-/**
- * Tool name parameter schema
- */
-export declare const ToolNameParamSchema: z.ZodObject<{
-    name: z.ZodString;
-}, z.core.$strip>;
-/**
- * Tool search query schema
- */
-export declare const ToolSearchQuerySchema: z.ZodObject<{
-    q: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-}, z.core.$strip>;
-/**
- * Generic ID parameter schema (for session endpoints using :id)
- */
-export declare const IdParamSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-/**
- * Sessions list query schema (with optional pagination and filtering)
- */
-export declare const SessionsListQuerySchema: z.ZodObject<{
-    userId: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-    offset: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-}, z.core.$strip>;
-/**
- * Session messages query schema (for pagination)
- */
-export declare const SessionMessagesQuerySchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-    offset: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-}, z.core.$strip>;
-/**
- * Embed request schema (single text)
- */
-export declare const EmbedRequestSchema: z.ZodObject<{
-    text: z.ZodString;
-    provider: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Embed many request schema (batch texts)
- */
-export declare const EmbedManyRequestSchema: z.ZodObject<{
-    texts: z.ZodArray<z.ZodString>;
-    provider: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Skill create request schema
- */
-export declare const SkillCreateRequestSchema: z.ZodObject<{
-    name: z.ZodString;
-    displayName: z.ZodOptional<z.ZodString>;
-    description: z.ZodString;
-    instructions: z.ZodString;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    scope: z.ZodOptional<z.ZodEnum<{
-        global: "global";
-        scoped: "scoped";
-    }>>;
-    scopeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    requestedBy: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Skill update request schema — all fields optional (patch semantics)
- */
-export declare const SkillUpdateRequestSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    displayName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    description: z.ZodOptional<z.ZodString>;
-    instructions: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-        global: "global";
-        scoped: "scoped";
-    }>>>;
-    scopeIds: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    requestedBy: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-/**
- * Type guard to check if a value is an ErrorResponse
- */
-export declare function isErrorResponse(value: unknown): value is ErrorResponse;
-/**
- * Create a standardized error response
- */
-export declare function createErrorResponse(code: string, message: string, details?: unknown, requestId?: string, httpStatus?: number): ErrorResponse;
-/**
- * Validate request body against a Zod schema
- */
-export declare function validateRequest<T>(schema: z.ZodSchema<T>, data: unknown, requestId?: string): ServerValidationResult<T>;
-/**
- * Validate query parameters against a Zod schema
- */
-export declare function validateQuery<T>(schema: z.ZodSchema<T>, query: Record<string, string>, requestId?: string): ServerValidationResult<T>;
-/**
- * Validate path parameters against a Zod schema
- */
-export declare function validateParams<T>(schema: z.ZodSchema<T>, params: Record<string, string>, requestId?: string): ServerValidationResult<T>;