@juspay/neurolink 9.54.6 → 9.54.7

package/dist/workflow/core/workflowRunner.js

@@ -11,8 +11,11 @@
  *
  * @module workflow/core/workflowRunner
  */
+import { SpanStatusCode } from "@opentelemetry/api";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 import { getModelGroups, PLACEHOLDER_MODEL, PLACEHOLDER_PROVIDER, usesModelGroups, } from "../config.js";
 import { validateWorkflow } from "../utils/workflowValidation.js";
 import { executeEnsemble, executeModelGroups } from "./ensembleExecutor.js";
@@ -45,156 +48,172 @@ import { conditionResponse } from "./responseConditioner.js";
  * ```
  */
 export async function runWorkflow(config, options) {
-    const startTime = Date.now();
-    const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run", {
-        "workflow.operation": "run",
-        "workflow.name": config.name,
-        "workflow.type": config.type,
-        "workflow.id": config.id,
-    });
-    // Validate configuration
-    const validation = validateWorkflow(config);
-    if (!validation.valid) {
-        span.durationMs = Date.now() - startTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
-        getMetricsAggregator().recordSpan(endedSpan);
-        throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
-    }
-    if (options.verbose) {
-        logger.debug(`[WorkflowRunner] Starting workflow: ${config.name}`);
-        logger.debug(`[WorkflowRunner] Type: ${config.type}`);
-        logger.debug(`[WorkflowRunner] Uses layer-based execution: ${usesModelGroups(config)}`);
-    }
-    try {
-        // Step 1: Execute models (layer-based or flat)
-        const ensembleResult = await executeModels(config, options);
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Received ${ensembleResult.responses.length} model responses`);
-            logger.debug(`[WorkflowRunner] Successful: ${ensembleResult.successCount}`);
-        }
-        // Step 2: Score responses with judge(s)
-        const scoreResult = await scoreResponses(config, ensembleResult.responses, options);
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Scoring complete`);
-            logger.debug(`[WorkflowRunner] Scores:`, scoreResult.scores);
+    return withSpan({
+        name: "neurolink.workflow.run",
+        tracer: tracers.sdk,
+        attributes: {
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id ?? "unknown",
+        },
+    }, async (otelSpan) => {
+        const startTime = Date.now();
+        const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run", {
+            "workflow.operation": "run",
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id,
+        });
+        // Validate configuration
+        const validation = validateWorkflow(config);
+        if (!validation.valid) {
+            span.durationMs = Date.now() - startTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+            getMetricsAggregator().recordSpan(endedSpan);
+            throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
         }
-        // Step 3: Select best response
-        const bestResponse = selectBestResponse(ensembleResult.responses, scoreResult.scores);
         if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Best response: ${bestResponse.model}`);
-            const bestScore = extractScore(scoreResult.scores, bestResponse, ensembleResult.responses);
-            logger.debug(`[WorkflowRunner] Best score: ${bestScore}`);
-        }
-        // CRITICAL: Store original content BEFORE any processing
-        const originalContent = bestResponse.content;
-        // Step 4: Get processed content
-        // Priority: Judge-synthesized > Separate conditioning > Original
-        let processedContent;
-        let conditioningTime = 0;
-        const judgeScores = isJudgeScores(scoreResult.scores)
-            ? scoreResult.scores
-            : convertToJudgeScores(scoreResult.scores);
-        if (judgeScores.synthesizedResponse) {
-            // Judge already synthesized improved response
-            processedContent = judgeScores.synthesizedResponse;
-            logger.debug(`[WorkflowRunner] Using judge-synthesized response`);
+            logger.debug(`[WorkflowRunner] Starting workflow: ${config.name}`);
+            logger.debug(`[WorkflowRunner] Type: ${config.type}`);
+            logger.debug(`[WorkflowRunner] Uses layer-based execution: ${usesModelGroups(config)}`);
         }
-        else if (config.conditioning) {
-            // Fall back to separate conditioning if configured
-            const conditionedContent = await conditionFinalResponse(bestResponse, scoreResult.scores, config, options, ensembleResult.responses);
-            processedContent = conditionedContent.content;
-            conditioningTime = conditionedContent.conditioningTime;
-            logger.debug(`[WorkflowRunner] Using separate conditioning`);
-        }
-        else {
-            // No processing, use original
-            processedContent = originalContent;
-            logger.debug(`[WorkflowRunner] No conditioning applied`);
-        }
-        // Step 5: Calculate execution metrics
-        const executionTime = Date.now() - startTime;
-        const ensembleTime = ensembleResult.totalTime;
-        const judgeTime = scoreResult.judgeTime;
-        // Step 6: Assemble complete result
-        const result = {
-            // Primary output (processed version)
-            content: processedContent,
-            // IMPORTANT: Store original unmodified response separately
-            originalContent: originalContent,
-            // Evaluation metrics (0-100 scale)
-            score: extractScore(scoreResult.scores, bestResponse, ensembleResult.responses),
-            reasoning: extractReasoning(scoreResult.scores),
-            // Ensemble data
-            ensembleResponses: ensembleResult.responses,
-            // Judge data
-            judgeScores: judgeScores,
-            selectedResponse: bestResponse,
-            // Quality metrics
-            confidence: extractConfidence(scoreResult.scores),
-            consensus: extractConsensus(scoreResult.scores),
-            // Performance metrics
-            totalTime: executionTime,
-            ensembleTime,
-            judgeTime,
-            conditioningTime: conditioningTime,
-            // Workflow metadata
-            workflow: config.id,
-            workflowName: config.name,
-            workflowVersion: config.version,
-            // Resource usage
-            usage: {
-                totalInputTokens: calculateInputTokens(ensembleResult.responses),
-                totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
-                totalTokens: calculateTotalTokens(ensembleResult.responses),
-                byModel: [], // TODO: Populate per-model breakdown
-            },
-            // Additional metadata
-            metadata: options.metadata,
-            timestamp: new Date().toISOString(),
-        };
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Workflow complete in ${executionTime}ms`);
-            logger.debug(`[WorkflowRunner] Total tokens: ${result.usage?.totalTokens || 0}`);
+        try {
+            // Step 1: Execute models (layer-based or flat)
+            const ensembleResult = await executeModels(config, options);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Received ${ensembleResult.responses.length} model responses`);
+                logger.debug(`[WorkflowRunner] Successful: ${ensembleResult.successCount}`);
+            }
+            // Step 2: Score responses with judge(s)
+            const scoreResult = await scoreResponses(config, ensembleResult.responses, options);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Scoring complete`);
+                logger.debug(`[WorkflowRunner] Scores:`, scoreResult.scores);
+            }
+            // Step 3: Select best response
+            const bestResponse = selectBestResponse(ensembleResult.responses, scoreResult.scores);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Best response: ${bestResponse.model}`);
+                const bestScore = extractScore(scoreResult.scores, bestResponse, ensembleResult.responses);
+                logger.debug(`[WorkflowRunner] Best score: ${bestScore}`);
+            }
+            // CRITICAL: Store original content BEFORE any processing
+            const originalContent = bestResponse.content;
+            // Step 4: Get processed content
+            // Priority: Judge-synthesized > Separate conditioning > Original
+            let processedContent;
+            let conditioningTime = 0;
+            const judgeScores = isJudgeScores(scoreResult.scores)
+                ? scoreResult.scores
+                : convertToJudgeScores(scoreResult.scores);
+            if (judgeScores.synthesizedResponse) {
+                // Judge already synthesized improved response
+                processedContent = judgeScores.synthesizedResponse;
+                logger.debug(`[WorkflowRunner] Using judge-synthesized response`);
+            }
+            else if (config.conditioning) {
+                // Fall back to separate conditioning if configured
+                const conditionedContent = await conditionFinalResponse(bestResponse, scoreResult.scores, config, options, ensembleResult.responses);
+                processedContent = conditionedContent.content;
+                conditioningTime = conditionedContent.conditioningTime;
+                logger.debug(`[WorkflowRunner] Using separate conditioning`);
+            }
+            else {
+                // No processing, use original
+                processedContent = originalContent;
+                logger.debug(`[WorkflowRunner] No conditioning applied`);
+            }
+            // Step 5: Calculate execution metrics
+            const executionTime = Date.now() - startTime;
+            const ensembleTime = ensembleResult.totalTime;
+            const judgeTime = scoreResult.judgeTime;
+            // Step 6: Assemble complete result
+            const result = {
+                // Primary output (processed version)
+                content: processedContent,
+                // IMPORTANT: Store original unmodified response separately
+                originalContent: originalContent,
+                // Evaluation metrics (0-100 scale)
+                score: extractScore(scoreResult.scores, bestResponse, ensembleResult.responses),
+                reasoning: extractReasoning(scoreResult.scores),
+                // Ensemble data
+                ensembleResponses: ensembleResult.responses,
+                // Judge data
+                judgeScores: judgeScores,
+                selectedResponse: bestResponse,
+                // Quality metrics
+                confidence: extractConfidence(scoreResult.scores),
+                consensus: extractConsensus(scoreResult.scores),
+                // Performance metrics
+                totalTime: executionTime,
+                ensembleTime,
+                judgeTime,
+                conditioningTime: conditioningTime,
+                // Workflow metadata
+                workflow: config.id,
+                workflowName: config.name,
+                workflowVersion: config.version,
+                // Resource usage
+                usage: {
+                    totalInputTokens: calculateInputTokens(ensembleResult.responses),
+                    totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
+                    totalTokens: calculateTotalTokens(ensembleResult.responses),
+                    byModel: [], // TODO: Populate per-model breakdown
+                },
+                // Additional metadata
+                metadata: options.metadata,
+                timestamp: new Date().toISOString(),
+            };
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Workflow complete in ${executionTime}ms`);
+                logger.debug(`[WorkflowRunner] Total tokens: ${result.usage?.totalTokens || 0}`);
+            }
+            span.durationMs = executionTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedSpan);
+            return result;
         }
-        span.durationMs = executionTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-        getMetricsAggregator().recordSpan(endedSpan);
-        return result;
-    }
-    catch (error) {
-        const executionTime = Date.now() - startTime;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (options.verbose) {
-            logger.error(`[WorkflowRunner] Workflow failed:`, errorMessage);
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (options.verbose) {
+                logger.error(`[WorkflowRunner] Workflow failed:`, errorMessage);
+            }
+            span.durationMs = executionTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
+            getMetricsAggregator().recordSpan(endedSpan);
+            // Mark outer OTel span as ERROR since we return instead of rethrowing
+            otelSpan.recordException(error instanceof Error ? error : new Error(errorMessage));
+            otelSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: errorMessage,
+            });
+            // Return error result with dummy data
+            const dummyResponse = {
+                provider: PLACEHOLDER_PROVIDER,
+                model: PLACEHOLDER_MODEL,
+                content: "",
+                responseTime: 0,
+                status: "failure",
+                error: errorMessage,
+                timestamp: new Date().toISOString(),
+            };
+            return {
+                content: "",
+                score: 0,
+                reasoning: `Workflow execution failed: ${errorMessage}`,
+                ensembleResponses: [dummyResponse],
+                confidence: 0,
+                totalTime: executionTime,
+                ensembleTime: 0,
+                workflow: config.id,
+                workflowName: config.name,
+                workflowVersion: config.version,
+                metadata: options.metadata,
+                timestamp: new Date().toISOString(),
+            };
         }
-        span.durationMs = executionTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
-        getMetricsAggregator().recordSpan(endedSpan);
-        // Return error result with dummy data
-        const dummyResponse = {
-            provider: PLACEHOLDER_PROVIDER,
-            model: PLACEHOLDER_MODEL,
-            content: "",
-            responseTime: 0,
-            status: "failure",
-            error: errorMessage,
-            timestamp: new Date().toISOString(),
-        };
-        return {
-            content: "",
-            score: 0,
-            reasoning: `Workflow execution failed: ${errorMessage}`,
-            ensembleResponses: [dummyResponse],
-            confidence: 0,
-            totalTime: executionTime,
-            ensembleTime: 0,
-            workflow: config.id,
-            workflowName: config.name,
-            workflowVersion: config.version,
-            metadata: options.metadata,
-            timestamp: new Date().toISOString(),
-        };
-    }
+    }); // end withSpan
 }
 /**
  * Execute models using layer-based or flat execution
@@ -459,6 +478,18 @@ function calculateTotalTokens(responses) {
  * ```
  */
 export async function* runWorkflowWithStreaming(config, options) {
+    // Wrap the generator in an active OTel span so Pipeline A captures the
+    // streaming workflow end-to-end and Pipeline B (below) inherits its traceId.
+    const generator = tracers.workflow.startActiveSpan("neurolink.workflow.run.streaming", {
+        attributes: {
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id ?? "unknown",
+        },
+    }, (otelSpan) => runWorkflowStreamingInner(config, options, otelSpan));
+    yield* generator;
+}
+async function* runWorkflowStreamingInner(config, options, otelSpan) {
     const startTime = Date.now();
     const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run.streaming", {
         "workflow.operation": "run.streaming",
@@ -469,14 +500,21 @@ export async function* runWorkflowWithStreaming(config, options) {
     // Validate configuration
     const validation = validateWorkflow(config);
     if (!validation.valid) {
+        const errMsg = `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`;
         span.durationMs = Date.now() - startTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errMsg);
         getMetricsAggregator().recordSpan(endedSpan);
-        throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+        const err = new Error(errMsg);
+        otelSpan.recordException(err);
+        otelSpan.setStatus({ code: SpanStatusCode.ERROR, message: errMsg });
+        otelSpan.end();
+        throw err;
     }
     if (options.verbose) {
         logger.debug(`[WorkflowRunner] Starting streaming workflow: ${config.name}`);
     }
+    // eslint-disable-next-line no-useless-assignment -- read in finally block
+    let spanEnded = false;
     try {
         // Step 1: Execute models
         const ensembleResult = await executeModels(config, options);
@@ -571,16 +609,33 @@ export async function* runWorkflowWithStreaming(config, options) {
         span.durationMs = executionTime;
         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
         getMetricsAggregator().recordSpan(endedSpan);
+        spanEnded = true;
+        otelSpan.setStatus({ code: SpanStatusCode.OK });
+        otelSpan.end();
     }
     catch (error) {
+        spanEnded = true;
         const executionTime = Date.now() - startTime;
         const errorMessage = error instanceof Error ? error.message : String(error);
         span.durationMs = executionTime;
         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
         getMetricsAggregator().recordSpan(endedSpan);
+        if (error instanceof Error) {
+            otelSpan.recordException(error);
+        }
+        otelSpan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+        otelSpan.end();
         logger.error(`[WorkflowRunner] Streaming workflow failed`, {
             error: errorMessage,
         });
         throw error;
     }
+    finally {
+        // Guard against span leak when the consumer breaks out of the async
+        // generator early (neither try-success nor catch fires in that case).
+        if (!spanEnded) {
+            otelSpan.setStatus({ code: SpanStatusCode.OK });
+            otelSpan.end();
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.54.6",
+  "version": "9.54.7",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
@@ -351,6 +351,7 @@
     "shell-quote": "^1.8.3",
     "svelte": "^5.53.6",
     "svelte-check": "^4.4.4",
+    "ts-morph": "^24.0.0",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",
     "typedoc": "^0.28.17",