@juspay/neurolink 9.54.6 → 9.54.8

package/dist/telemetry/traceContext.js

@@ -0,0 +1,18 @@
+import { trace, context } from "@opentelemetry/api";
+/**
+ * Extract the current OTel trace context for use by Pipeline B spans.
+ * Returns undefined values when no OTel context is active, allowing
+ * Pipeline B spans to share the same trace as Pipeline A spans.
+ */
+export function getActiveTraceContext() {
+    const activeSpan = trace.getSpan(context.active());
+    if (!activeSpan) {
+        return {};
+    }
+    const ctx = activeSpan.spanContext();
+    // Invalid trace IDs are all zeros — don't use those
+    if (!ctx.traceId || ctx.traceId === "00000000000000000000000000000000") {
+        return {};
+    }
+    return { traceId: ctx.traceId, parentSpanId: ctx.spanId };
+}

package/dist/telemetry/tracers.d.ts

@@ -14,4 +14,6 @@ export declare const tracers: {
     readonly processor: import("@opentelemetry/api").Tracer;
     readonly file: import("@opentelemetry/api").Tracer;
     readonly autoresearch: import("@opentelemetry/api").Tracer;
+    readonly auth: import("@opentelemetry/api").Tracer;
+    readonly workflow: import("@opentelemetry/api").Tracer;
 };

package/dist/telemetry/tracers.js

@@ -15,4 +15,6 @@ export const tracers = {
     processor: trace.getTracer("neurolink.processor"),
     file: trace.getTracer("neurolink.file"),
     autoresearch: trace.getTracer("neurolink.autoresearch"),
+    auth: trace.getTracer("neurolink.auth"),
+    workflow: trace.getTracer("neurolink.workflow"),
 };

package/dist/types/action.d.ts

@@ -203,3 +203,5 @@ export type ActionInputValidation = {
 export type ProviderKeyMapping = {
     [K in AIProviderName]?: (keyof ActionProviderKeys)[];
 };
+/** Provider-to-required-keys map used by actionInputs.ts. */
+export type ProviderKeyMap = Record<string, string[]>;

package/dist/types/artifact.d.ts

@@ -61,3 +61,10 @@ export type ArtifactStore = {
     /** Generate a short preview string from a serialized payload. */
     generatePreview(payload: string): string;
 };
+/**
+ * In-memory index row tracked by LocalTempArtifactStore.
+ * Combines metadata with the on-disk path.
+ */
+export type IndexEntry = ArtifactMeta & {
+    path: string;
+};

package/dist/types/auth.d.ts

@@ -820,24 +820,6 @@ export type AuthEventHandler = (event: AuthEventData) => void | Promise<void>;
  * Auth provider factory function type
  */
 export type AuthProviderFactoryFn = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
-/**
- * Auth provider registration entry
- */
-export type AuthProviderRegistration = {
-    /** Provider type */
-    type: AuthProviderType;
-    /** Factory function */
-    factory: AuthProviderFactoryFn;
-    /** Provider aliases */
-    aliases: string[];
-    /** Provider metadata */
-    metadata?: {
-        name: string;
-        description: string;
-        version?: string;
-        documentation?: string;
-    };
-};
 /**
  * Auth health check result
  */
@@ -1031,3 +1013,128 @@ export type SessionManagerStorage = {
     /** Health check */
     isHealthy(): Promise<boolean>;
 };
+/** Cached JWKS entry with TTL. Used by Cognito and Keycloak providers. */
+export type AuthJWKSCacheEntry = {
+    jwks: JWKS;
+    expiresAt: number;
+};
+/** Async constructor for an auth provider given its config. */
+export type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+/** Registration row for an auth provider in AuthProviderFactory. */
+export type AuthProviderRegistration = {
+    factory: AuthProviderConstructor;
+    aliases: string[];
+    metadata?: AuthProviderMetadata;
+};
+/** Synthetic Claude Code client identity used for quota + identification. */
+export type ClaudeCodeIdentity = {
+    deviceId: string;
+    accountUuid: string;
+    sessionId: string;
+    metadataUserId: string;
+};
+/** Minimal request object accepted by the auth middleware. */
+export type IncomingRequest = {
+    method?: string;
+    url?: string;
+    path?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    cookies?: Record<string, string>;
+    query?: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    ip?: string;
+    user?: AuthUser;
+    authContext?: AuthenticatedContext;
+};
+/** Minimal Express-style response object used by the auth middleware. */
+export type OutgoingResponse = {
+    status(code: number): OutgoingResponse;
+    json(body: unknown): void;
+};
+/** Middleware handler function type for the auth layer. */
+export type AuthMiddlewareHandler<TContext = AuthRequestContext> = (context: TContext) => Promise<AuthMiddlewareResult>;
+/** Result produced by an auth middleware handler. */
+export type AuthMiddlewareResult = {
+    proceed: boolean;
+    context?: AuthenticatedContext;
+    error?: {
+        statusCode: number;
+        message: string;
+        code?: string;
+    };
+};
+/** Next-function for Express-style middleware chaining. */
+export type NextFunction = () => Promise<void>;
+/** Express-style auth middleware signature. */
+export type ExpressMiddleware = (req: IncomingRequest, res: OutgoingResponse, next: NextFunction) => Promise<void>;
+/** Token bucket state for a single user. */
+export type TokenBucket = {
+    tokens: number;
+    lastRefill: number;
+    userId: string;
+};
+/** Rate limit configuration per user or role. */
+export type AuthRateLimitConfig = {
+    maxRequests: number;
+    windowMs: number;
+    roleLimits?: Record<string, number>;
+    userLimits?: Record<string, number>;
+    skipRoles?: string[];
+    message?: string;
+};
+/** Rate limit result. */
+export type RateLimitResult = {
+    allowed: boolean;
+    remaining: number;
+    resetIn: number;
+    limit: number;
+    error?: string;
+};
+/** Result of an atomic consume operation against a token bucket. */
+export type AtomicConsumeResult = {
+    bucket: TokenBucket;
+    consumed: boolean;
+};
+/** Storage contract for rate-limit buckets (memory or Redis). */
+export type RateLimitStorage = {
+    getBucket(userId: string): Promise<TokenBucket | null>;
+    setBucket(userId: string, bucket: TokenBucket): Promise<void>;
+    deleteBucket(userId: string): Promise<void>;
+    healthCheck(): Promise<boolean>;
+    cleanup(): Promise<void>;
+    atomicConsume?(userId: string, limit: number, windowMs: number, nowMs: number): Promise<AtomicConsumeResult | null>;
+};
+/**
+ * Minimal Redis client shape used by the rate-limiter to avoid a hard
+ * dependency on the full `RedisClientType`. Named with an Auth prefix to
+ * avoid collision with `RedisClientType` from the redis package.
+ */
+export type AuthRateLimitRedisClient = {
+    connect(): Promise<void>;
+    quit(): Promise<void>;
+    ping(): Promise<string>;
+    get(key: string): Promise<string | null>;
+    setEx(key: string, seconds: number, value: string): Promise<void>;
+    del(key: string): Promise<number>;
+    eval(script: string, numkeys: number, ...args: string[]): Promise<unknown>;
+};
+/** Middleware-level outcome returned by the rate limiter. */
+export type RateLimitMiddlewareResult = {
+    proceed: boolean;
+    rateLimitResult: RateLimitResult;
+    response?: Response;
+};
+/** Auth0 JWT payload structure. */
+export type Auth0TokenPayload = {
+    sub: string;
+    email?: string;
+    name?: string;
+    picture?: string;
+    email_verified?: boolean;
+    roles?: string[];
+    permissions?: string[];
+    iat: number;
+    exp: number;
+    aud: string | string[];
+    iss: string;
+};

package/dist/types/autoresearch.d.ts

@@ -5,6 +5,10 @@
  * experiments, evaluates results against a deterministic metric, and
  * keeps or discards each change — running unattended for hours.
  */
+import type { RepoPolicy } from "../autoresearch/repoPolicy.js";
+import type { ResearchStateStore } from "../autoresearch/stateStore.js";
+import type { ResultRecorder } from "../autoresearch/resultRecorder.js";
+import type { ExperimentRunner } from "../autoresearch/runner.js";
 import type { ThinkingLevel } from "./config.js";
 export type MetricDirection = "lower" | "higher";
 export type MetricConfig = {
@@ -192,3 +196,11 @@ export declare const AUTORESEARCH_DEFAULTS: {
     readonly branchPrefix: "autoresearch/";
     readonly thinkingLevel: ThinkingLevel;
 };
+/** Dependencies required to create research tools. */
+export type ResearchToolsDeps = {
+    config: ResearchConfig;
+    stateStore: ResearchStateStore;
+    repoPolicy: RepoPolicy;
+    runner: ExperimentRunner;
+    recorder: ResultRecorder;
+};

package/dist/types/cli.d.ts

@@ -577,6 +577,11 @@ export type SetupArgs = {
     interactive?: boolean;
     help?: boolean;
 };
+/**
+ * Narrowed ProviderInfo used by the main `neurolink setup` command,
+ * where the descriptive fields are always populated.
+ */
+export type SetupProviderInfo = ProviderInfo & Required<Pick<ProviderInfo, "bestFor" | "models" | "strengths" | "pricing" | "setupCommand">>;
 /**
  * Provider information for setup display
  */
@@ -1075,3 +1080,413 @@ export type SetupResult = {
         responseTime?: number;
     }>;
 };
+/**
+ * Shared options for every provider-specific CLI setup command
+ * (anthropic, azure, bedrock, gcp, google-ai, openai).
+ */
+export type ProviderSetupOptions = {
+    checkOnly?: boolean;
+    interactive?: boolean;
+};
+/** Shared yargs-argv shape for every provider-specific CLI setup command. */
+export type ProviderSetupArgv = {
+    check?: boolean;
+    nonInteractive?: boolean;
+};
+/**
+ * Superset provider-setup config. `endpoint` is Azure-only; other providers
+ * leave it undefined. Pre-consolidation there were 4 near-duplicate types
+ * (Anthropic/Azure/GoogleAI/OpenAI); they are now one.
+ */
+export type ProviderSetupConfig = {
+    apiKey?: string;
+    model?: string;
+    endpoint?: string;
+    isReconfiguring?: boolean;
+};
+/** Providers supported by the `neurolink auth` command. */
+export type SupportedProvider = "anthropic";
+/** Arguments for `neurolink autoresearch init`. */
+export type AutoresearchInitArgs = {
+    repoPath: string;
+    tag: string;
+    target: string;
+    immutable: string;
+    runCommand: string;
+    metricName: string;
+    metricPattern: string;
+    metricDirection: string;
+    timeout: number;
+    provider?: string;
+    model?: string;
+};
+/** Base options shared across all `neurolink evaluate` subcommands. */
+export type BaseEvaluateArgs = {
+    json?: boolean;
+    verbose?: boolean;
+    format?: "text" | "json" | "table";
+};
+/** Arguments for the bare `neurolink evaluate` invocation. */
+export type DirectEvaluateArgs = BaseEvaluateArgs & {
+    input?: string;
+    query?: string;
+    scorers?: string[];
+    context?: string;
+    threshold?: number;
+};
+/** Arguments for `neurolink evaluate run`. */
+export type EvaluateRunArgs = BaseEvaluateArgs & {
+    input?: string;
+    output?: string;
+    context?: string[];
+    groundTruth?: string;
+    pipeline?: string;
+    scorer?: string[];
+};
+/** Arguments for `neurolink evaluate score`. */
+export type EvaluateScoreArgs = BaseEvaluateArgs & {
+    scorer: string;
+    input?: string;
+    output?: string;
+    context?: string[];
+    groundTruth?: string;
+};
+/** Arguments for `neurolink evaluate report`. */
+export type EvaluateReportArgs = BaseEvaluateArgs & {
+    input?: string;
+    output?: string;
+    context?: string[];
+    groundTruth?: string;
+    "ground-truth"?: string;
+    pipeline?: string;
+    scorer?: string[];
+    outputFile?: string;
+    "output-file"?: string;
+};
+/** Arguments for `neurolink evaluate presets`. */
+export type EvaluatePresetsArgs = {
+    preset?: string;
+    json?: boolean;
+};
+/** Arguments for `neurolink evaluate scorers` (list-scorers). */
+export type EvaluateScorersArgs = {
+    category?: string;
+    type?: string;
+    json?: boolean;
+    detailed?: boolean;
+};
+/** Arguments for `neurolink evaluate run-pipeline`. */
+export type RunPipelineArgs = BaseEvaluateArgs & {
+    preset: string;
+    input: string;
+    query?: string;
+    context?: string;
+    threshold?: number;
+};
+/** Info row for an MCP tool annotation. */
+export type ToolAnnotationInfo = {
+    serverName: string;
+    serverId: string;
+    toolName: string;
+    description: string;
+    annotations: import("./mcp.js").MCPToolAnnotations;
+};
+/** Tool target used by the annotation printer. */
+export type AnnotatedToolTarget = {
+    name: string;
+    description: string;
+    serverId: string;
+    serverName: string;
+};
+/** Arguments for `neurolink rag chunk`. */
+export type RagChunkArgs = import("./rag.js").RAGCommandArgs & {
+    file: string;
+    output?: string;
+    extract?: boolean;
+};
+/** Arguments for `neurolink rag index`. */
+export type RagIndexArgs = import("./rag.js").RAGCommandArgs & {
+    file: string;
+    indexName?: string;
+};
+/** Arguments for `neurolink rag query`. */
+export type RagQueryArgs = import("./rag.js").RAGCommandArgs & {
+    query: string;
+    indexName?: string;
+};
+/** Minimal server instance contract used by `neurolink serve`. */
+export type ServerInstance = {
+    initialize: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    registerRouteGroup: (group: import("./server.js").RouteGroup) => void;
+    listRoutes?: () => import("./server.js").RouteDefinition[];
+};
+/** Persisted state for a running `neurolink serve` process. */
+export type ServeState = {
+    pid: number;
+    port: number;
+    host: string;
+    framework: string;
+    startTime: string;
+    basePath: string;
+    configFile?: string;
+};
+/** Captured Bedrock setup configuration data. */
+export type BedrockConfigData = {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+    model?: string;
+};
+/** Status of Bedrock setup configuration flags. */
+export type BedrockConfigStatus = {
+    hasAccessKey: boolean;
+    hasSecretKey: boolean;
+    hasRegion: boolean;
+};
+/** Status of each GCP auth method tried by setup-gcp. */
+export type GcpAuthMethodStatus = {
+    method1: {
+        complete: boolean;
+        hasCredentials: boolean;
+        missingVars: string[];
+    };
+    method2: {
+        complete: boolean;
+        hasServiceAccountKey: boolean;
+        missingVars: string[];
+    };
+    method3: {
+        complete: boolean;
+        hasClientEmail: boolean;
+        hasPrivateKey: boolean;
+        missingVars: string[];
+    };
+    common: {
+        hasProject: boolean;
+        hasLocation: boolean;
+        missingVars: string[];
+    };
+};
+/** Arguments for `neurolink setup huggingface`. */
+export type SetupHuggingFaceArgs = {
+    check?: boolean;
+    "non-interactive"?: boolean;
+};
+/** Arguments for `neurolink setup mistral`. */
+export type SetupMistralArgs = {
+    check?: boolean;
+    "non-interactive"?: boolean;
+};
+/** Arguments for `neurolink task create`. */
+export type TaskCreateArgs = {
+    name: string;
+    prompt: string;
+    cron?: string;
+    timezone?: string;
+    every?: string;
+    at?: string;
+    mode: string;
+    provider?: string;
+    model?: string;
+    maxRuns?: number;
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+};
+/** Arguments for `neurolink task update`. */
+export type TaskUpdateArgs = {
+    taskId: string;
+    prompt?: string;
+    cron?: string;
+    every?: string;
+    at?: string;
+    mode?: string;
+};
+/** Arguments for `neurolink task logs`. */
+export type TaskLogsArgs = {
+    taskId: string;
+    limit: number;
+    status?: string;
+    full?: boolean;
+};
+/** Arguments for `neurolink voice-server`. */
+export type VoiceServerArgs = {
+    port: number;
+};
+/** Provider config row used by the interactive setup wizard. */
+export type InteractiveProviderConfig = {
+    id: AIProviderName;
+    name: string;
+    description: string;
+    envVars: Array<{
+        key: string;
+        prompt: string;
+        secure?: boolean;
+        default?: string;
+        optional?: boolean;
+    }>;
+};
+/** Result of saving video to file. */
+export type VideoSaveResult = {
+    success: boolean;
+    path: string;
+    size: number;
+    error?: string;
+};
+/** Provider identifier recognized by the `neurolink config` command. */
+export type CliConfigProvider = "auto" | "openai" | "bedrock" | "vertex" | "anthropic" | "azure" | "google-ai" | "huggingface" | "ollama" | "mistral";
+/** Analytics config for the healthcare evaluation domain. */
+export type CliHealthcareAnalyticsConfig = {
+    trackPatientData: boolean;
+    trackDiagnosticAccuracy: boolean;
+    trackTreatmentOutcomes: boolean;
+};
+/** Analytics config for the analytics evaluation domain. */
+export type CliAnalyticsDomainAnalyticsConfig = {
+    trackDataQuality: boolean;
+    trackModelPerformance: boolean;
+    trackBusinessImpact: boolean;
+};
+/** Analytics config for the finance evaluation domain. */
+export type CliFinanceAnalyticsConfig = {
+    trackRiskMetrics: boolean;
+    trackRegulatory: boolean;
+    trackPortfolioImpact: boolean;
+};
+/** Analytics config for the ecommerce evaluation domain. */
+export type CliEcommerceAnalyticsConfig = {
+    trackConversions: boolean;
+    trackUserBehavior: boolean;
+    trackRevenueImpact: boolean;
+};
+/** Generic shape of a single domain entry in the CLI config. */
+export type CliDomainConfig<TAnalytics extends Record<string, boolean> = Record<string, boolean>> = {
+    evaluationCriteria: string[];
+    analyticsConfig: TAnalytics;
+};
+/**
+ * Materialized shape of the CLI config parsed from `~/.neurolink/config.json`.
+ * Matches the output of `ConfigSchema.parse()` defined in
+ * `src/cli/commands/config.ts`. The schema is annotated with
+ * `z.ZodType<CliNeuroLinkConfig>` so drift fails at compile time.
+ */
+export type CliNeuroLinkConfig = {
+    defaultProvider: CliConfigProvider;
+    providers: {
+        openai?: {
+            apiKey?: string;
+            model: string;
+            baseURL?: string;
+        };
+        bedrock?: {
+            region?: string;
+            accessKeyId?: string;
+            secretAccessKey?: string;
+            sessionToken?: string;
+            model: string;
+        };
+        vertex?: {
+            projectId?: string;
+            location: string;
+            credentials?: string;
+            serviceAccountKey?: string;
+            clientEmail?: string;
+            privateKey?: string;
+            model: string;
+        };
+        anthropic?: {
+            apiKey?: string;
+            model: string;
+        };
+        azure?: {
+            apiKey?: string;
+            endpoint?: string;
+            deploymentId?: string;
+            model: string;
+        };
+        "google-ai"?: {
+            apiKey?: string;
+            model: string;
+        };
+        huggingface?: {
+            apiKey?: string;
+            model: string;
+        };
+        ollama?: {
+            baseUrl: string;
+            model: string;
+            timeout: number;
+        };
+        mistral?: {
+            apiKey?: string;
+            model: string;
+        };
+    };
+    profiles: Record<string, unknown>;
+    preferences: {
+        outputFormat: "text" | "json" | "yaml";
+        temperature: number;
+        maxTokens?: number;
+        enableLogging: boolean;
+        enableCaching: boolean;
+        cacheStrategy: "memory" | "file" | "redis";
+        defaultEvaluationDomain?: string;
+        enableAnalyticsByDefault: boolean;
+        enableEvaluationByDefault: boolean;
+    };
+    domains: {
+        healthcare: CliDomainConfig<CliHealthcareAnalyticsConfig>;
+        analytics: CliDomainConfig<CliAnalyticsDomainAnalyticsConfig>;
+        finance: CliDomainConfig<CliFinanceAnalyticsConfig>;
+        ecommerce: CliDomainConfig<CliEcommerceAnalyticsConfig>;
+    };
+};
+/** Row in the MCP tools listing produced by `neurolink mcp tools`. */
+export type MCPToolWithServer = {
+    name: string;
+    description: string;
+    serverId: string;
+    serverName: string;
+    inputSchema?: object;
+    category?: string;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        requiresConfirmation?: boolean;
+        tags?: string[];
+    };
+};
+/** Per-server discovery result produced by `neurolink mcp discover`. */
+export type MCPDiscoveryResult = {
+    serverId: string;
+    serverName: string;
+    toolCount: number;
+    tools: Array<{
+        name: string;
+        description: string;
+        annotations: Record<string, unknown>;
+    }>;
+};
+/**
+ * Minimal route-group shape reflected at runtime by `neurolink serve routes`.
+ * Named with a `CliServe` prefix to disambiguate from the richer RouteGroup
+ * in server.ts (§Rule 9).
+ */
+export type CliServeRouteGroup = {
+    prefix: string;
+    routes: Array<{
+        method: string;
+        path: string;
+        description?: string;
+    }>;
+};
+/** Flat per-route row used by the `neurolink serve routes` listing. */
+export type CliServeFlatRoute = {
+    method: string;
+    path: string;
+    description?: string;
+    group: string;
+};

package/dist/types/client.d.ts

@@ -1251,3 +1251,37 @@ export type ClientWebSocketConfig = WSClientConfig;
 export type ClientWebSocketMessage = WSClientMessage;
 /** @see WSClientEventHandlers */
 export type WebSocketEventHandlers = WSClientEventHandlers;
+/**
+ * Superset internal config for SSE and WebSocket client wrappers.
+ * The 9 shared fields are required. Protocol-specific fields
+ * (useNativeEventSource for SSE; heartbeatInterval/queueSize for WS)
+ * are optional — each client populates only its own fields.
+ */
+export type ClientInternalConfig = {
+    baseUrl: string;
+    apiKey: string;
+    token: string;
+    timeout: number;
+    headers: Record<string, string>;
+    autoReconnect: boolean;
+    maxReconnectAttempts: number;
+    reconnectDelay: number;
+    maxReconnectDelay: number;
+    useNativeEventSource?: boolean;
+    heartbeatInterval?: number;
+    queueSize?: number;
+};
+/**
+ * Internal stream chunk format used by the AI-SDK adapter's push/pull queue.
+ * Distinct from the public NeuroLink `StreamChunk` (stream.ts) — this one
+ * mirrors the underlying `ai` package event shape (text-delta / finish).
+ */
+export type AiSdkStreamChunk = {
+    type: "text-delta" | "finish";
+    textDelta?: string;
+    finishReason?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+};