@juspay/neurolink 9.54.5 → 9.54.7

package/dist/types/scorer.d.ts

@@ -421,3 +421,144 @@ export type ReportConfig = {
     /** Include timing information */
     includeTiming?: boolean;
 };
+/** Similarity metric types. */
+export type SimilarityMetric = "jaccard" | "cosine" | "levenshtein" | "dice" | "overlap";
+/** Configuration specific to content similarity scoring. */
+export type ContentSimilarityConfig = RuleScorerConfig & {
+    metric?: SimilarityMetric;
+    metrics?: SimilarityMetric[];
+    metricCombination?: "average" | "min" | "max" | "weighted";
+    metricWeights?: Record<SimilarityMetric, number>;
+    normalizeText?: boolean;
+    tokenLevel?: "word" | "character" | "ngram";
+    ngramSize?: number;
+    compareWith?: "groundTruth" | "context" | "custom";
+    referenceText?: string;
+};
+/** Similarity calculation detail row. */
+export type SimilarityDetails = {
+    metric: SimilarityMetric;
+    score: number;
+    responseTokens: number;
+    referenceTokens: number;
+    commonTokens?: number;
+};
+/** Expected format types evaluated by the format scorer. */
+export type FormatType = "json" | "markdown" | "code" | "list" | "numbered-list" | "bullet-list" | "table" | "yaml" | "xml" | "plain" | "html" | "custom";
+/** Code language types for the code-format validator. */
+export type CodeLanguage = "javascript" | "typescript" | "python" | "java" | "c" | "cpp" | "csharp" | "go" | "rust" | "sql" | "bash" | "any";
+/** Configuration specific to format scoring. */
+export type FormatScorerConfig = RuleScorerConfig & {
+    expectedFormat?: FormatType;
+    allowedFormats?: FormatType[];
+    codeLanguage?: CodeLanguage;
+    jsonSchema?: object;
+    markdownRequirements?: {
+        hasHeadings?: boolean;
+        hasCodeBlocks?: boolean;
+        hasLinks?: boolean;
+        hasLists?: boolean;
+        minHeadingLevel?: number;
+        maxHeadingLevel?: number;
+    };
+    listRequirements?: {
+        minItems?: number;
+        maxItems?: number;
+        itemPattern?: string;
+    };
+    customPattern?: string;
+    strictFormat?: boolean;
+};
+/** Format validation result. */
+export type FormatValidationResult = {
+    isValid: boolean;
+    detectedFormat: FormatType | null;
+    issues: string[];
+    structureAnalysis?: object;
+};
+/** Configuration specific to keyword coverage scoring. */
+export type KeywordCoverageConfig = RuleScorerConfig & {
+    keywords?: string[];
+    minCoverage?: number;
+    caseInsensitive?: boolean;
+    wordBoundary?: boolean;
+    synonyms?: Record<string, string[]>;
+    keywordWeights?: Record<string, number>;
+};
+/** Keyword coverage result details. */
+export type KeywordCoverageDetails = {
+    totalKeywords: number;
+    foundKeywords: string[];
+    missingKeywords: string[];
+    coverageRatio: number;
+    weightedCoverage: number;
+};
+/** Length measurement unit. */
+export type LengthUnit = "words" | "characters" | "sentences" | "paragraphs" | "tokens";
+/** Length constraint type. */
+export type LengthConstraintType = "exact" | "range" | "minimum" | "maximum" | "ratio";
+/** Configuration specific to length scoring. */
+export type LengthScorerConfig = RuleScorerConfig & {
+    unit?: LengthUnit;
+    constraintType?: LengthConstraintType;
+    minLength?: number;
+    maxLength?: number;
+    exactLength?: number;
+    tolerance?: number;
+    ratioTarget?: number;
+    ratioReference?: "query" | "context";
+    scoringMode?: "binary" | "proportional";
+};
+/** Length measurement result. */
+export type LengthMeasurement = {
+    words: number;
+    characters: number;
+    sentences: number;
+    paragraphs: number;
+    estimatedTokens: number;
+};
+/** Row describing a built-in scorer in the scorer registry seed list. */
+export type BuiltInScorerDefinition = {
+    metadata: ScorerMetadata;
+    factory: ScorerFactory;
+    aliases?: string[];
+};
+/** Bias instance reported by the bias-detection scorer. */
+export type BiasInstance = {
+    type?: string;
+    text?: string;
+    explanation?: string;
+    severity?: string;
+};
+/** Context score row reported by the context-relevancy scorer. */
+export type ContextScoreItem = {
+    index?: number;
+    score?: number;
+    reasoning?: string;
+    keyInfo?: string[];
+};
+/** Claim row reported by the faithfulness scorer. */
+export type ClaimItem = {
+    claim?: string;
+    supported?: boolean;
+    evidence?: string;
+};
+/** Hallucination row reported by the hallucination scorer. */
+export type HallucinationItem = {
+    text?: string;
+    reason?: string;
+    severity?: string;
+};
+/** Tone-shift location reported by the tone-consistency scorer. */
+export type ToneShift = {
+    location?: string;
+    from?: string;
+    to?: string;
+    severity?: string;
+};
+/** Flagged content row reported by the toxicity scorer. */
+export type FlaggedItem = {
+    text?: string;
+    category?: string;
+    severity?: string;
+};

package/dist/types/server.d.ts

@@ -1010,3 +1010,102 @@ export type CacheEntry = {
     ttlMs: number;
     headers?: Record<string, string>;
 };
+/** Voice-server conversation turn — superset role set. */
+export type Message = {
+    role: "system" | "user" | "assistant";
+    content: string;
+};
+/** Subset of Message that excludes the system role (assistant+user only). */
+export type ConversationMessage = {
+    role: "user" | "assistant";
+    content: string;
+};
+/** Configuration passed to the OpenAPI spec generator. */
+export type OpenAPIGeneratorConfig = {
+    info?: {
+        title?: string;
+        version?: string;
+        description?: string;
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    includeSecurity?: boolean;
+    basePath?: string;
+    additionalTags?: Array<{
+        name: string;
+        description: string;
+    }>;
+    customSchemas?: Record<string, JsonObject>;
+    routes?: RouteDefinition[];
+};
+/** Structured OpenAPI 3.1 specification object. */
+export type OpenAPISpec = {
+    openapi: "3.1.0";
+    info: JsonObject;
+    servers: JsonObject[];
+    tags: JsonObject[];
+    paths: Record<string, JsonObject>;
+    components: {
+        schemas: Record<string, JsonObject>;
+        securitySchemes?: Record<string, JsonObject>;
+        parameters?: Record<string, JsonObject>;
+    };
+    security?: JsonObject[];
+};
+/** Options for createAllRoutes / createRoutes. */
+export type CreateRoutesOptions = {
+    enableSwagger?: boolean;
+    getRoutes?: () => RouteDefinition[];
+    claudeProxy?: boolean;
+};
+/** Data stream finish event. */
+export type FinishEvent = DataStreamEvent & {
+    type: "finish";
+    data: {
+        reason?: string;
+        usage?: {
+            input: number;
+            output: number;
+            total: number;
+        };
+    };
+};
+/** Configuration for DataStreamWriter. */
+export type DataStreamWriterConfig = {
+    write: (chunk: string) => void | Promise<void>;
+    close?: () => void | Promise<void>;
+    format?: "sse" | "ndjson";
+    includeTimestamps?: boolean;
+};
+/** Configuration for the DataStreamResponse wrapper. */
+export type DataStreamResponseConfig = {
+    contentType?: "text/event-stream" | "application/x-ndjson";
+    headers?: Record<string, string>;
+    keepAliveInterval?: number;
+    includeTimestamps?: boolean;
+};
+/** Options for a single SSE message. */
+export type SSEEventOptions = {
+    event?: string;
+    data: string;
+    id?: string;
+    retry?: number;
+};
+/** Single token emitted by the Soniox STT stream. */
+export type SonioxToken = {
+    is_final?: boolean;
+    text?: string;
+};
+/** Envelope received from the Soniox STT WebSocket. */
+export type SonioxMessage = {
+    error?: string;
+    status?: string;
+    type?: string;
+    tokens?: SonioxToken[];
+};
+/** Control message received from the voice client over WebSocket. */
+export type ClientControlMessage = {
+    type?: string;
+};

package/dist/types/span.d.ts

@@ -48,7 +48,8 @@ export declare enum SpanType {
 export declare enum SpanStatus {
     UNSET = 0,
     OK = 1,
-    ERROR = 2
+    ERROR = 2,
+    WARNING = 3
 }
 /**
  * OpenTelemetry GenAI semantic conventions

package/dist/types/span.js

@@ -51,6 +51,7 @@ export var SpanStatus;
     SpanStatus[SpanStatus["UNSET"] = 0] = "UNSET";
     SpanStatus[SpanStatus["OK"] = 1] = "OK";
     SpanStatus[SpanStatus["ERROR"] = 2] = "ERROR";
+    SpanStatus[SpanStatus["WARNING"] = 3] = "WARNING";
 })(SpanStatus || (SpanStatus = {}));
 /**
  * OpenTelemetry GenAI semantic conventions

package/dist/types/tools.d.ts

@@ -3,6 +3,7 @@
  * argument patterns, execution metadata, context, and result types.
  */
 import { z } from "zod";
+import type { Tool } from "ai";
 import type { ErrorInfo, JsonObject, JsonValue, Result, UnknownRecord } from "./common.js";
 import type { StandardRecord, StringArray, ZodUnknownSchema } from "./aliases.js";
 import type { ValidationError } from "../utils/parameterValidation.js";
@@ -357,6 +358,49 @@ export type SimpleTool<TArgs = ToolArgs, TResult = JsonValue> = {
     metadata?: ToolMetadata;
     execute: (params: TArgs, context?: ToolContext) => Promise<TResult>;
 };
+/**
+ * Simple tool type accepted by the SDK registerTool() helper. Uses
+ * SDKToolContext (richer tool context with request metadata).
+ */
+export type SdkSimpleTool<TArgs = ToolArgs, TResult = JsonValue> = Omit<SimpleTool<TArgs, TResult>, "execute"> & {
+    description: string;
+    parameters?: ZodUnknownSchema;
+    execute: (params: TArgs, context?: SDKToolContext) => Promise<TResult>;
+    metadata?: {
+        category?: string;
+        version?: string;
+        author?: string;
+        tags?: string[];
+        documentation?: string;
+        [key: string]: JsonValue | undefined;
+    };
+};
+/** Subset of directAgentTools exposing only the "basic" category. */
+export type BasicToolsMap = {
+    getCurrentTime: Tool;
+    calculateMath: Tool;
+};
+/** Subset of directAgentTools exposing only the "filesystem" category. */
+export type FilesystemToolsMap = {
+    readFile: Tool;
+    listDirectory: Tool;
+    writeFile: Tool;
+};
+/** Subset of directAgentTools exposing the "utility" category. */
+export type UtilityToolsMap = {
+    getCurrentTime: Tool;
+    calculateMath: Tool;
+    listDirectory: Tool;
+};
+/** Full directAgentTools map, with the opt-in bashTool appended. */
+export type AllToolsMap = {
+    getCurrentTime: Tool;
+    calculateMath: Tool;
+    readFile: Tool;
+    listDirectory: Tool;
+    writeFile: Tool;
+    executeBashCommand?: Tool;
+};
 /**
  * Tool registry entry
  */

package/dist/types/tts.d.ts

@@ -167,3 +167,9 @@ export type TTSChunk = {
     /** Sample rate in Hz */
     sampleRate?: number;
 };
+/** Message envelope received from the Cartesia TTS WebSocket. */
+export type CartesiaMessage = {
+    data?: string;
+    done?: boolean;
+    error?: string;
+};

package/dist/types/utilities.d.ts

@@ -241,3 +241,25 @@ export type ImageCacheStats = {
     /** Cache hit rate as percentage */
     hitRate: number;
 };
+/**
+ * Pending request held by TokenBucketRateLimiter's queue.
+ * Named RateLimiterPendingRequest to disambiguate from the MCP
+ * PendingRequest in mcp.ts (Rule 9).
+ */
+export type RateLimiterPendingRequest = {
+    resolve: () => void;
+    reject: (error: Error) => void;
+    timestamp: number;
+    timeoutTimer?: ReturnType<typeof setTimeout>;
+};
+/**
+ * Shape of a completed tool result as returned by the AI SDK in
+ * `onStepFinish`. Both `output` (AI SDK v4) and `result` (older shape)
+ * are supported so the helper works across SDK versions.
+ */
+export type StepToolResult = {
+    toolName: string;
+    output?: unknown;
+    result?: unknown;
+    error?: string;
+};

package/dist/types/workflow.d.ts

@@ -4,6 +4,7 @@
  *
  * Testing Phase: Focuses on original output + evaluation metrics for AB testing
  */
+import type { z } from "zod";
 import type { AnalyticsData } from "./analytics.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { JsonValue } from "./common.js";
@@ -578,3 +579,20 @@ export type RunWorkflowOptions = {
     /** Enable progressive streaming (yield preliminary response) */
     streaming?: boolean;
 };
+/**
+ * Generic workflow validation result — replaces three near-identical types
+ * (WorkflowConfigValidationResult, ModelConfigValidationResult,
+ * JudgeConfigValidationResult). Named with `Workflow*` prefix to avoid
+ * collision with `tools.ts#ValidationResult` (Rule 9).
+ */
+export type WorkflowValidation<T> = {
+    success: boolean;
+    data?: T;
+    error?: z.ZodError;
+};
+/** Progressive workflow response chunk streamed by runWorkflow(). */
+export type WorkflowStreamChunk = {
+    type: "preliminary" | "final";
+    content: string;
+    partialResult?: Partial<WorkflowResult>;
+};

package/dist/utils/async/retry.d.ts

@@ -3,16 +3,11 @@
  *
  * Provides retry logic with exponential backoff for resilient async operations.
  */
-import type { AsyncRetryOptions } from "../../types/index.js";
-/**
- * Local alias: the canonical type was renamed to AsyncRetryOptions to avoid
- * collision with other RetryOptions types in the codebase.
- */
-type RetryOptions = AsyncRetryOptions;
+import type { RetryOptions } from "../../types/index.js";
 /**
  * Default retry configuration.
  */
-export declare const DEFAULT_RETRY_OPTIONS: RetryOptions;
+export declare const DEFAULT_RETRY_OPTIONS: Required<Pick<RetryOptions, "maxAttempts" | "initialDelay" | "maxDelay" | "backoffMultiplier">>;
 /**
  * Calculate exponential backoff delay with optional jitter.
  *
@@ -110,4 +105,3 @@ export declare function retry<T>(fn: () => Promise<T>, options?: Partial<RetryOp
  * ```
  */
 export declare function createRetry(defaultOptions: Partial<RetryOptions>): <T>(fn: () => Promise<T>, overrideOptions?: Partial<RetryOptions>) => Promise<T>;
-export {};

package/dist/utils/async/retry.js

@@ -8,9 +8,9 @@ import { delay } from "./delay.js";
  * Default retry configuration.
  */
 export const DEFAULT_RETRY_OPTIONS = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 30000,
+    maxAttempts: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
     backoffMultiplier: 2,
 };
 /**
@@ -109,11 +109,11 @@ export async function retry(fn, options = {}) {
         ...DEFAULT_RETRY_OPTIONS,
         ...options,
     };
-    const { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier = 2, shouldRetry = () => true, onRetry, } = config;
+    const { maxAttempts, initialDelay, maxDelay, backoffMultiplier, retryCondition = () => true, onRetry, } = config;
     let lastError = new Error("Retry failed");
-    let currentDelay = baseDelayMs;
+    let currentDelay = initialDelay;
     // Total attempts = initial attempt + retries
-    const totalAttempts = maxRetries + 1;
+    const totalAttempts = maxAttempts + 1;
     for (let attempt = 1; attempt <= totalAttempts; attempt++) {
         try {
             return await fn();
@@ -126,14 +126,14 @@ export async function retry(fn, options = {}) {
                 throw new RetryExhaustedError(`All ${totalAttempts} retry attempts exhausted`, totalAttempts, err);
             }
             // Check if we should retry this error
-            if (!shouldRetry(err, attempt)) {
+            if (!retryCondition(err)) {
                 throw err;
             }
             // Calculate delay with exponential backoff (capped at maxDelay)
-            const delayMs = Math.min(currentDelay, maxDelayMs);
+            const delayMs = Math.min(currentDelay, maxDelay);
             // Notify about retry
             if (onRetry) {
-                onRetry(err, attempt, delayMs);
+                onRetry(attempt, err);
             }
             // Wait before next attempt
             await delay(delayMs);

package/dist/utils/imageCompressor.d.ts

@@ -1,27 +1,8 @@
-import type { ProviderName } from "../types/index.js";
-declare const SUPPORTED_FORMATS: readonly ["jpeg", "png", "webp"];
-type SupportedFormat = (typeof SUPPORTED_FORMATS)[number];
+import type { CompressionOptions, CompressionResult, ProviderName } from "../types/index.js";
 /**
  * Provider-specific image size limits in bytes
  */
 export declare const PROVIDER_IMAGE_LIMITS: Record<ProviderName, number>;
-type CompressionOptions = {
-    provider: ProviderName;
-    quality?: number;
-    maxDimension?: number;
-    format?: SupportedFormat;
-};
-type CompressionResult = {
-    buffer: Buffer;
-    originalSize: number;
-    compressedSize: number;
-    compressionRatio: number;
-    metadata: {
-        width: number;
-        height: number;
-        format: string;
-    };
-};
 /**
  * Compress an image to meet provider-specific size limits
  * @param imageBuffer - Input image buffer
@@ -42,4 +23,3 @@ export declare function needsCompression(imageBuffer: Buffer, provider: Provider
  * @returns Size limit in bytes
  */
 export declare function getProviderSizeLimit(provider: ProviderName): number;
-export {};

package/dist/utils/imageCompressor.js

@@ -1,6 +1,10 @@
 import sharp from "sharp";
 import { withTimeout } from "./async/index.js";
-const SUPPORTED_FORMATS = ["jpeg", "png", "webp"];
+const SUPPORTED_FORMATS = [
+    "jpeg",
+    "png",
+    "webp",
+];
 const IMAGE_COMPRESSION_TIMEOUT_MS = 30_000;
 /**
  * Provider-specific image size limits in bytes

package/dist/utils/messageBuilder.d.ts

@@ -4,7 +4,7 @@
  * Enhanced with multimodal support for images
  */
 import type { ModelMessage } from "ai";
-import type { MultimodalChatMessage, GenerateOptions, TextGenerationOptions, StreamOptions } from "../types/index.js";
+import type { GenerateOptions, MultimodalChatMessage, StreamOptions, TextGenerationOptions } from "../types/index.js";
 /**
  * Type-safe conversion from MultimodalChatMessage[] to ModelMessage[]
  * Filters out invalid content and ensures strict ModelMessage contract compliance

package/dist/utils/redis.d.ts

@@ -2,9 +2,7 @@
  * Redis Utilities for NeuroLink
  * Helper functions for Redis storage operations
  */
-import { createClient } from "redis";
-import type { RedisConversationObject, RedisStorageConfig } from "../types/index.js";
-type RedisClient = ReturnType<typeof createClient>;
+import type { RedisClient, RedisConversationObject, RedisStorageConfig } from "../types/index.js";
 /**
  * Get a pooled Redis connection. Multiple callers with the same host:port:db
  * share a single connection, reducing connection count.
@@ -60,4 +58,3 @@ export declare function scanKeys(client: RedisClient, pattern: string, batchSize
  * Get normalized Redis configuration with defaults
  */
 export declare function getNormalizedConfig(config: RedisStorageConfig): Required<RedisStorageConfig>;
-export {};

package/dist/utils/sanitizers/filename.d.ts

@@ -10,7 +10,6 @@
  * @see https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html
  */
 import type { SanitizeFileNameOptions, SanitizeDisplayNameOptions } from "../../types/index.js";
-export type { SanitizeFileNameOptions, SanitizeDisplayNameOptions };
 /**
  * Sanitize a filename for safe filesystem storage.
  * Removes characters that are invalid on various operating systems.

package/dist/utils/toolEndEmitter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * toolEndEmitter — shared helper for emitting `tool:end` events from
+ * AI-SDK `onStepFinish` callbacks.
+ *
+ * Pipeline B (metrics aggregator) listens for `tool:end` on the NeuroLink
+ * EventEmitter. When tools are executed by the AI SDK internally (via
+ * `generateText` / `streamText`) the SDK calls `onStepFinish` with the
+ * completed tool results. Without this helper those results are silently
+ * stored but never surfaced as `tool:end` events, leaving Pipeline B with
+ * zero tool spans for AI-SDK-driven tool calls (gaps G5 and S2).
+ *
+ * @module utils/toolEndEmitter
+ */
+import type { NeuroLinkEvents, StepToolResult, TypedEventEmitter } from "../types/index.js";
+/**
+ * Emit a `tool:end` event for every completed tool result in an
+ * `onStepFinish` callback.
+ *
+ * @param emitter - The NeuroLink event emitter (obtained via
+ *   `neurolink.getEventEmitter()`).  When `undefined` the function is a
+ *   no-op so callers need not guard every call site.
+ * @param toolResults - The `toolResults` array from `onStepFinish`.  When
+ *   `undefined` or empty the function is a no-op.
+ */
+export declare function emitToolEndFromStepFinish(emitter: TypedEventEmitter<NeuroLinkEvents> | undefined, toolResults: StepToolResult[] | undefined): void;

package/dist/utils/toolEndEmitter.js

@@ -0,0 +1,64 @@
+/**
+ * toolEndEmitter — shared helper for emitting `tool:end` events from
+ * AI-SDK `onStepFinish` callbacks.
+ *
+ * Pipeline B (metrics aggregator) listens for `tool:end` on the NeuroLink
+ * EventEmitter. When tools are executed by the AI SDK internally (via
+ * `generateText` / `streamText`) the SDK calls `onStepFinish` with the
+ * completed tool results. Without this helper those results are silently
+ * stored but never surfaced as `tool:end` events, leaving Pipeline B with
+ * zero tool spans for AI-SDK-driven tool calls (gaps G5 and S2).
+ *
+ * @module utils/toolEndEmitter
+ */
+import { createToolEventPayload } from "../core/toolEvents.js";
+/**
+ * Emit a `tool:end` event for every completed tool result in an
+ * `onStepFinish` callback.
+ *
+ * @param emitter - The NeuroLink event emitter (obtained via
+ *   `neurolink.getEventEmitter()`).  When `undefined` the function is a
+ *   no-op so callers need not guard every call site.
+ * @param toolResults - The `toolResults` array from `onStepFinish`.  When
+ *   `undefined` or empty the function is a no-op.
+ */
+export function emitToolEndFromStepFinish(emitter, toolResults) {
+    if (!emitter || !toolResults || toolResults.length === 0) {
+        return;
+    }
+    for (const tr of toolResults) {
+        const output = tr.output ?? tr.result;
+        const isError = !!tr.error ||
+            (output !== null &&
+                output !== undefined &&
+                typeof output === "object" &&
+                "isError" in output &&
+                output.isError === true);
+        let errorMessage;
+        if (isError) {
+            if (tr.error) {
+                errorMessage = tr.error;
+            }
+            else if (output && typeof output === "object") {
+                const content = output.content;
+                if (Array.isArray(content)) {
+                    const texts = content
+                        .filter((c) => c.type === "text" && c.text)
+                        .map((c) => c.text);
+                    errorMessage =
+                        texts.length > 0 ? texts.join(" ") : "Tool returned isError: true";
+                }
+                else {
+                    errorMessage = "Tool returned isError: true";
+                }
+            }
+        }
+        emitter.emit("tool:end", createToolEventPayload(tr.toolName, {
+            responseTime: 0,
+            success: !isError,
+            timestamp: Date.now(),
+            result: output,
+            error: errorMessage,
+        }));
+    }
+}