@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/evaluation/reporting/metricsCollector.d.ts

@@ -2,65 +2,7 @@
  * @file Metrics Collector
  * Collect and aggregate evaluation metrics
  */
-import type { ScoreResult, PipelineResult } from "../../types/index.js";
-/**
- * Scorer metrics
- */
-type ScorerMetrics = {
-    scorerId: string;
-    scorerName: string;
-    totalExecutions: number;
-    successfulExecutions: number;
-    failedExecutions: number;
-    passedCount: number;
-    failedCount: number;
-    totalScore: number;
-    minScore: number;
-    maxScore: number;
-    totalDuration: number;
-    averageDuration: number;
-    averageScore: number;
-    passRate: number;
-    lastExecutionTime: number;
-};
-/**
- * Pipeline metrics
- */
-type PipelineMetrics = {
-    pipelineName: string;
-    totalExecutions: number;
-    passedCount: number;
-    failedCount: number;
-    totalScore: number;
-    minScore: number;
-    maxScore: number;
-    totalDuration: number;
-    averageDuration: number;
-    averageScore: number;
-    passRate: number;
-    lastExecutionTime: number;
-    scorerMetrics: Map<string, ScorerMetrics>;
-};
-/**
- * Aggregated metrics
- */
-type AggregatedMetrics = {
-    totalEvaluations: number;
-    overallPassRate: number;
-    averageScore: number;
-    averageDuration: number;
-    scoreDistribution: {
-        excellent: number;
-        good: number;
-        fair: number;
-        poor: number;
-        failing: number;
-    };
-    pipelineMetrics: Map<string, PipelineMetrics>;
-    scorerMetrics: Map<string, ScorerMetrics>;
-    collectionStartTime: number;
-    lastUpdateTime: number;
-};
+import type { AggregatedMetrics, PipelineMetrics, PipelineResult, ScoreResult, ScorerMetrics } from "../../types/index.js";
 /**
  * Metrics collector for evaluation data
  */
@@ -144,4 +86,3 @@ export declare function createMetricsCollector(): MetricsCollector;
  * Global metrics collector instance
  */
 export declare const globalMetricsCollector: MetricsCollector;
-export {};

package/dist/lib/evaluation/reporting/reportGenerator.d.ts

@@ -2,22 +2,7 @@
  * @file Report Generator
  * Generate evaluation reports in various formats
  */
-import type { ReportData, ReportConfig, ReportFormat } from "../../types/index.js";
-/**
- * Generated report
- */
-type GeneratedReport = {
-    /** Report format */
-    format: ReportFormat;
-    /** Report content */
-    content: string;
-    /** Metadata */
-    metadata: {
-        generatedAt: number;
-        format: ReportFormat;
-        config: ReportConfig;
-    };
-};
+import type { GeneratedReport, ReportConfig, ReportData } from "../../types/index.js";
 /**
  * Report generator class
  */
@@ -70,4 +55,3 @@ export declare const Reports: {
     /** Generate HTML report */
     html: (data: ReportData) => GeneratedReport;
 };
-export {};

package/dist/lib/evaluation/scorers/rule/contentSimilarityScorer.d.ts

@@ -2,35 +2,8 @@
  * @file Content Similarity Scorer
  * Evaluates text similarity using various metrics (Jaccard, cosine, Levenshtein)
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput } from "../../../types/index.js";
+import type { ContentSimilarityConfig, ScoreResult, ScorerInput } from "../../../types/index.js";
 import { BaseScorer } from "../baseScorer.js";
-/**
- * Similarity metric types
- */
-type SimilarityMetric = "jaccard" | "cosine" | "levenshtein" | "dice" | "overlap";
-/**
- * Configuration specific to content similarity scoring
- */
-type ContentSimilarityConfig = RuleScorerConfig & {
-    /** Similarity metric to use */
-    metric?: SimilarityMetric;
-    /** Multiple metrics to combine */
-    metrics?: SimilarityMetric[];
-    /** How to combine multiple metrics */
-    metricCombination?: "average" | "min" | "max" | "weighted";
-    /** Weights for each metric (if weighted combination) */
-    metricWeights?: Record<SimilarityMetric, number>;
-    /** Whether to normalize text before comparison */
-    normalizeText?: boolean;
-    /** Whether to use word-level or character-level comparison */
-    tokenLevel?: "word" | "character" | "ngram";
-    /** N-gram size if using ngram tokenization */
-    ngramSize?: number;
-    /** Compare against ground truth, context, or custom reference */
-    compareWith?: "groundTruth" | "context" | "custom";
-    /** Custom reference text if compareWith is "custom" */
-    referenceText?: string;
-};
 /**
  * ContentSimilarityScorer evaluates how similar the response is to a reference text
  */
@@ -106,4 +79,3 @@ export declare class ContentSimilarityScorer extends BaseScorer {
  * Factory function for creating ContentSimilarityScorer instances
  */
 export declare function createContentSimilarityScorer(config?: ContentSimilarityConfig): Promise<ContentSimilarityScorer>;
-export {};

package/dist/lib/evaluation/scorers/rule/formatScorer.d.ts

@@ -2,48 +2,8 @@
  * @file Format Scorer
  * Evaluates response format compliance (JSON, markdown, code, etc.)
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { FormatScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Expected format types
- */
-type FormatType = "json" | "markdown" | "code" | "list" | "numbered-list" | "bullet-list" | "table" | "yaml" | "xml" | "plain" | "html" | "custom";
-/**
- * Code language types for code format validation
- */
-type CodeLanguage = "javascript" | "typescript" | "python" | "java" | "c" | "cpp" | "csharp" | "go" | "rust" | "sql" | "bash" | "any";
-/**
- * Configuration specific to format scoring
- */
-type FormatScorerConfig = RuleScorerConfig & {
-    /** Expected format type */
-    expectedFormat?: FormatType;
-    /** Multiple allowed formats */
-    allowedFormats?: FormatType[];
-    /** For code format: expected language */
-    codeLanguage?: CodeLanguage;
-    /** For JSON format: validate against schema */
-    jsonSchema?: object;
-    /** For markdown: required elements */
-    markdownRequirements?: {
-        hasHeadings?: boolean;
-        hasCodeBlocks?: boolean;
-        hasLinks?: boolean;
-        hasLists?: boolean;
-        minHeadingLevel?: number;
-        maxHeadingLevel?: number;
-    };
-    /** For list format: requirements */
-    listRequirements?: {
-        minItems?: number;
-        maxItems?: number;
-        itemPattern?: string;
-    };
-    /** Custom format regex pattern */
-    customPattern?: string;
-    /** Whether format must be exclusive (no other content) */
-    strictFormat?: boolean;
-};
 /**
  * FormatScorer evaluates response format against expected formats
  */
@@ -145,4 +105,3 @@ export declare const FormatScorerPresets: {
     /** Plain text only */
     readonly plainText: () => FormatScorer;
 };
-export {};

package/dist/lib/evaluation/scorers/rule/keywordCoverageScorer.d.ts

@@ -2,25 +2,8 @@
  * @file Keyword Coverage Scorer
  * Evaluates how well the response covers expected keywords or topics
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { KeywordCoverageConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Configuration specific to keyword coverage scoring
- */
-type KeywordCoverageConfig = RuleScorerConfig & {
-    /** Keywords to check for */
-    keywords?: string[];
-    /** Minimum coverage ratio (0-1) to pass */
-    minCoverage?: number;
-    /** Whether to use case-insensitive matching */
-    caseInsensitive?: boolean;
-    /** Whether to use word boundary matching */
-    wordBoundary?: boolean;
-    /** Synonyms map for flexible matching */
-    synonyms?: Record<string, string[]>;
-    /** Weight different keywords differently */
-    keywordWeights?: Record<string, number>;
-};
 /**
  * KeywordCoverageScorer evaluates how well a response covers expected keywords
  */
@@ -81,4 +64,3 @@ export declare class KeywordCoverageScorer extends BaseRuleScorer {
  * Factory function for creating KeywordCoverageScorer instances
  */
 export declare function createKeywordCoverageScorer(config?: KeywordCoverageConfig): Promise<KeywordCoverageScorer>;
-export {};

package/dist/lib/evaluation/scorers/rule/lengthScorer.d.ts

@@ -2,39 +2,8 @@
  * @file Length Scorer
  * Evaluates response length against configured constraints
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { LengthScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Length measurement unit
- */
-type LengthUnit = "words" | "characters" | "sentences" | "paragraphs" | "tokens";
-/**
- * Length constraint type
- */
-type LengthConstraintType = "exact" | "range" | "minimum" | "maximum" | "ratio";
-/**
- * Configuration specific to length scoring
- */
-type LengthScorerConfig = RuleScorerConfig & {
-    /** Unit of measurement */
-    unit?: LengthUnit;
-    /** Constraint type */
-    constraintType?: LengthConstraintType;
-    /** Minimum length (for range/minimum constraints) */
-    minLength?: number;
-    /** Maximum length (for range/maximum constraints) */
-    maxLength?: number;
-    /** Exact length (for exact constraint) */
-    exactLength?: number;
-    /** Tolerance for exact length (as percentage) */
-    tolerance?: number;
-    /** Compare ratio with query/context length */
-    ratioTarget?: number;
-    /** Ratio reference: compare against query or context */
-    ratioReference?: "query" | "context";
-    /** Scoring mode: binary (pass/fail) or proportional */
-    scoringMode?: "binary" | "proportional";
-};
 /**
  * LengthScorer evaluates response length against configurable constraints
  */
@@ -103,4 +72,3 @@ export declare const LengthScorerPresets: {
     /** Tweet-length (max 280 characters) */
     readonly tweet: () => LengthScorer;
 };
-export {};

package/dist/lib/factories/providerFactory.d.ts

@@ -1,19 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { UnknownRecord, AIProvider, NeurolinkCredentials } from "../types/index.js";
-/**
- * Provider constructor interface - supports both sync constructors and async factory functions
- */
-type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
-/**
- * Provider registration entry
- */
-type ProviderRegistration = {
-    constructor: ProviderConstructor;
-    defaultModel?: string;
-    aliases?: string[];
-};
+import type { AIProvider, NeurolinkCredentials, ProviderConstructor, ProviderRegistration, UnknownRecord } from "../types/index.js";
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements
@@ -72,4 +58,3 @@ export declare class ProviderFactory {
  * Helper function to create providers with backward compatibility
  */
 export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
-export {};

package/dist/lib/factories/providerFactory.js

@@ -1,4 +1,6 @@
 import { logger } from "../utils/logger.js";
+// Pure factory pattern with no hardcoded imports
+// All providers loaded dynamically via registry to avoid circular dependencies
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements

package/dist/lib/image-gen/ImageGenService.d.ts

@@ -26,6 +26,9 @@
  * ```
  */
 import type { ImageGenConfig, ImageGenOptions, ImageGenResult } from "../types/index.js";
+/**
+ * NeuroLink instance type (avoiding circular dependencies)
+ */
 /**
  * Image generation service for AI-powered image creation
  *

package/dist/lib/image-gen/ImageGenService.js

@@ -27,6 +27,9 @@
  */
 import { withTimeout } from "../utils/errorHandling.js";
 import { DEFAULT_IMAGE_GEN_CONFIG } from "../types/index.js";
+/**
+ * NeuroLink instance type (avoiding circular dependencies)
+ */
 /**
  * Image generation service for AI-powered image creation
  *

package/dist/lib/mcp/batching/requestBatcher.js

@@ -10,6 +10,8 @@
 import { EventEmitter } from "events";
 import { logger } from "../../utils/logger.js";
 import { ErrorFactory } from "../../utils/errorHandling.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 /**
  * Request Batcher - Efficient batch processing for MCP tool calls
  *
@@ -217,85 +219,109 @@ export class RequestBatcher extends EventEmitter {
         const startTime = Date.now();
         this.activeBatches++;
         this.emit("batchStarted", { batchId, size: batchRequests.length });
-        try {
-            // Guard against missing executor
-            if (!this.executor) {
-                throw ErrorFactory.missingConfiguration("batchExecutor", {
-                    hint: "Call setExecutor() before executing batches",
-                });
-            }
-            // Execute the batch with a timeout to prevent indefinite hangs
-            const executorPromise = this.executor(batchRequests.map((r) => ({
-                tool: r.tool,
-                args: r.args,
-                serverId: r.serverId,
-            })));
-            const timeoutMs = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
-            let timeoutHandle;
-            const timeoutPromise = new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => reject(ErrorFactory.toolTimeout("batchExecution", timeoutMs)), timeoutMs);
-            });
-            const results = await Promise.race([
-                executorPromise,
-                timeoutPromise,
-            ]).finally(() => {
-                if (timeoutHandle) {
-                    clearTimeout(timeoutHandle);
-                }
-            });
-            // Process results
-            const batchResults = [];
-            for (let i = 0; i < batchRequests.length; i++) {
-                const request = batchRequests[i];
-                const result = results[i];
-                const executionTime = Date.now() - startTime;
-                if (!result) {
-                    const noResultError = ErrorFactory.toolExecutionFailed(request.tool, new Error(`Batch executor returned no result for request ${i}`));
-                    request.reject(noResultError);
-                    batchResults.push({
-                        id: request.id,
-                        success: false,
-                        error: noResultError,
-                        executionTime,
+        await withSpan({
+            name: "neurolink.mcp.batch.execute",
+            tracer: tracers.mcp,
+            attributes: {
+                "mcp.batch.id": batchId,
+                "mcp.batch.size": batchRequests.length,
+                "mcp.batch.active_batches": this.activeBatches,
+            },
+        }, async (span) => {
+            let successCount = 0;
+            let errorCount = 0;
+            try {
+                // Guard against missing executor
+                if (!this.executor) {
+                    throw ErrorFactory.missingConfiguration("batchExecutor", {
+                        hint: "Call setExecutor() before executing batches",
                     });
-                    continue;
                 }
-                if (result.success) {
-                    request.resolve(result.result);
-                    batchResults.push({
-                        id: request.id,
-                        success: true,
-                        result: result.result,
-                        executionTime,
-                    });
+                // Execute the batch with a timeout to prevent indefinite hangs
+                const executorPromise = this.executor(batchRequests.map((r) => ({
+                    tool: r.tool,
+                    args: r.args,
+                    serverId: r.serverId,
+                })));
+                const timeoutMs = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
+                let timeoutHandle;
+                const timeoutPromise = new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => reject(ErrorFactory.toolTimeout("batchExecution", timeoutMs)), timeoutMs);
+                });
+                // Suppress unhandled rejection if executorPromise rejects after timeout wins
+                void executorPromise.catch((_e) => {
+                    // Intentionally swallowed — timeout already handled the failure
+                });
+                const results = await Promise.race([
+                    executorPromise,
+                    timeoutPromise,
+                ]).finally(() => {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                });
+                // Process results
+                const batchResults = [];
+                for (let i = 0; i < batchRequests.length; i++) {
+                    const request = batchRequests[i];
+                    const result = results[i];
+                    const executionTime = Date.now() - startTime;
+                    if (!result) {
+                        const noResultError = ErrorFactory.toolExecutionFailed(request.tool, new Error(`Batch executor returned no result for request ${i}`));
+                        request.reject(noResultError);
+                        batchResults.push({
+                            id: request.id,
+                            success: false,
+                            error: noResultError,
+                            executionTime,
+                        });
+                        errorCount++;
+                        continue;
+                    }
+                    if (result.success) {
+                        request.resolve(result.result);
+                        batchResults.push({
+                            id: request.id,
+                            success: true,
+                            result: result.result,
+                            executionTime,
+                        });
+                        successCount++;
+                    }
+                    else {
+                        const error = result.error ??
+                            ErrorFactory.toolExecutionFailed(request.tool, new Error("Unknown batch execution error"));
+                        request.reject(error);
+                        batchResults.push({
+                            id: request.id,
+                            success: false,
+                            error,
+                            executionTime,
+                        });
+                        errorCount++;
+                    }
                 }
-                else {
-                    const error = result.error ??
-                        ErrorFactory.toolExecutionFailed(request.tool, new Error("Unknown batch execution error"));
-                    request.reject(error);
-                    batchResults.push({
-                        id: request.id,
-                        success: false,
-                        error,
-                        executionTime,
-                    });
+                span.setAttribute("mcp.batch.success_count", successCount);
+                span.setAttribute("mcp.batch.error_count", errorCount);
+                this.emit("batchCompleted", { batchId, results: batchResults });
+            }
+            catch (error) {
+                // Batch-level failure - reject all requests
+                const batchError = error instanceof Error
+                    ? error
+                    : ErrorFactory.toolExecutionFailed("batch", new Error(String(error)));
+                for (const request of batchRequests) {
+                    request.reject(batchError);
                 }
+                this.emit("batchFailed", { batchId, error: batchError });
+                throw batchError;
             }
-            this.emit("batchCompleted", { batchId, results: batchResults });
-        }
-        catch (error) {
-            // Batch-level failure - reject all requests
-            const batchError = error instanceof Error
-                ? error
-                : ErrorFactory.toolExecutionFailed("batch", new Error(String(error)));
-            for (const request of batchRequests) {
-                request.reject(batchError);
+            finally {
+                this.activeBatches--;
             }
-            this.emit("batchFailed", { batchId, error: batchError });
-        }
-        finally {
-            this.activeBatches--;
-        }
+        }).catch((error) => {
+            logger.error("Batch span execution failed:", error);
+        });
         // Schedule next batch if there are more pending requests
         if (this.pending.size > 0) {
             this.clearFlushTimer();

package/dist/lib/mcp/httpRateLimiter.js

@@ -5,6 +5,7 @@
  */
 import { mcpLogger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
  * Default rate limit configuration
  * Provides sensible defaults for most MCP HTTP transport use cases
@@ -72,12 +73,13 @@ export class HTTPRateLimiter {
      * @throws Error if the wait queue is too long
      */
     async acquire() {
+        const { traceId, parentSpanId } = getActiveTraceContext();
         const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.rateLimit", {
             "mcp.transport": "http",
             "mcp.operation": "rateLimit",
             "mcp.rateLimit.tokensAvailable": this.tokens,
             "mcp.rateLimit.maxBurst": this.config.maxBurst,
-        });
+        }, parentSpanId, traceId);
         const startTime = Date.now();
         try {
             // First, try to acquire without waiting

package/dist/lib/mcp/httpRetryHandler.js

@@ -8,6 +8,7 @@ import { isAbortError } from "../utils/errorHandling.js";
 import { calculateBackoffDelay } from "../utils/retryHandler.js";
 import { logger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
  * Default HTTP retry configuration
  */
@@ -130,11 +131,12 @@ export async function withHTTPRetry(operation, config = {}) {
         ...DEFAULT_HTTP_RETRY_CONFIG,
         ...config,
     };
+    const { traceId, parentSpanId } = getActiveTraceContext();
     const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.retry", {
         "mcp.transport": "http",
         "mcp.operation": "retry",
         "mcp.maxAttempts": mergedConfig.maxAttempts,
-    });
+    }, parentSpanId, traceId);
     const startTime = Date.now();
     let lastError;
     let actualAttempts = 0;

package/dist/lib/mcp/mcpClientFactory.js

@@ -17,6 +17,7 @@ import { withHTTPRetry, DEFAULT_HTTP_RETRY_CONFIG, } from "./httpRetryHandler.js
 import { globalRateLimiterManager } from "./httpRateLimiter.js";
 import { NeuroLinkOAuthProvider, InMemoryTokenStorage } from "./auth/index.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
  * Default timeout for MCP client creation in milliseconds.
  * Configurable via MCP_CLIENT_TIMEOUT env var.
@@ -46,11 +47,12 @@ export class MCPClientFactory {
      */
     static async createClient(config, timeout = DEFAULT_CLIENT_TIMEOUT) {
         const startTime = Date.now();
+        const { traceId, parentSpanId } = getActiveTraceContext();
         const obsSpan = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.connect", {
             "mcp.transport": config.transport,
             "mcp.operation": "connect",
             "mcp.server_id": config.id,
-        });
+        }, parentSpanId, traceId);
         try {
             mcpLogger.info(`[MCPClientFactory] Creating client for ${config.id}`, {
                 transport: config.transport,

package/dist/lib/mcp/multiServerManager.d.ts

@@ -15,19 +15,7 @@
  * @since 8.39.0
  */
 import { EventEmitter } from "events";
-import type { MCPServerInfo, JsonObject, MultiServerManagerConfig, ServerGroup, UnifiedTool } from "../types/index.js";
-/**
- * Server metrics for load balancing
- */
-type ServerMetrics = {
-    activeRequests: number;
-    totalRequests: number;
-    completedRequests: number;
-    averageResponseTime: number;
-    errorRate: number;
-    lastHealthCheck?: Date;
-    isHealthy: boolean;
-};
+import type { JsonObject, MCPServerInfo, MultiServerManagerConfig, ServerGroup, ServerMetrics, UnifiedTool } from "../types/index.js";
 /**
  * Multi-Server Manager
  *
@@ -192,4 +180,3 @@ export declare class MultiServerManager extends EventEmitter {
  * Global multi-server manager instance
  */
 export declare const globalMultiServerManager: MultiServerManager;
-export {};

package/dist/lib/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -8,7 +8,11 @@ import { AIProviderFactory } from "../../../core/factory.js";
 import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 import { logger } from "../../../utils/logger.js";
 /**
- * Input Schemas for AI Analysis Tools
+ * Input Schemas for AI Analysis Tools.
+ *
+ * Each schema is annotated with `z.ZodType<CanonicalParams>` so any drift
+ * between the structural type (declared in src/lib/types/mcp.ts) and the
+ * runtime zod schema fails at compile time.
  */
 const AnalyzeUsageSchema = z.object({
     sessionId: z.string().optional(),

package/dist/lib/mcp/servers/aiProviders/aiWorkflowTools.js

@@ -96,6 +96,7 @@ const debugAIOutputSchema = z.object({
         .default(true)
         .describe("Whether to include fix suggestions"),
 });
+// Type definitions for tool results
 /**
  * Generate test cases for code functions
  */