@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/workflow/config.d.ts

@@ -6,7 +6,7 @@
  */
 import { z } from "zod";
 import { AIProviderName } from "../constants/enums.js";
-import type { JsonValue, ConditioningConfig, ExecutionConfig, JudgeConfig, WorkflowModelConfig, ModelGroup, WorkflowConfig } from "../types/index.js";
+import type { JsonValue, ConditioningConfig, ExecutionConfig, JudgeConfig, WorkflowModelConfig, ModelGroup, WorkflowConfig, WorkflowValidation } from "../types/index.js";
 export declare const MIN_SCORE = 0;
 export declare const MAX_SCORE = 100;
 export declare const MAX_REASONING_LENGTH = 200;
@@ -41,9 +41,9 @@ export declare const JudgeConfigSchema: z.ZodObject<{
     criteria: z.ZodArray<z.ZodString>;
     outputFormat: z.ZodEnum<{
         scores: "scores";
-        detailed: "detailed";
         ranking: "ranking";
         best: "best";
+        detailed: "detailed";
     }>;
     customPrompt: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
@@ -195,9 +195,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
-            detailed: "detailed";
             ranking: "ranking";
             best: "best";
+            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
@@ -219,9 +219,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
-            detailed: "detailed";
             ranking: "ranking";
             best: "best";
+            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
@@ -330,54 +330,30 @@ export declare const DEFAULT_JUDGE_CONFIG: {
  * @returns Complete workflow configuration with defaults applied
  */
 export declare function mergeWithDefaults(config: WorkflowConfig): WorkflowConfig;
-/**
- * Validation result for workflow configuration
- */
-type WorkflowConfigValidationResult = {
-    success: boolean;
-    data?: WorkflowConfig;
-    error?: z.ZodError;
-};
 /**
  * Validate workflow configuration
  * @param config - Partial workflow configuration to validate
  * @returns Validation result with parsed data or error details
  */
-export declare function validateWorkflowConfig(config: Partial<WorkflowConfig>): WorkflowConfigValidationResult;
+export declare function validateWorkflowConfig(config: Partial<WorkflowConfig>): WorkflowValidation<WorkflowConfig>;
 /**
  * Create workflow configuration from partial
  * @param partial - Partial configuration with required fields (id, name, type, models)
  * @returns Complete workflow configuration with defaults applied
  */
 export declare function createWorkflowConfig(partial: Partial<WorkflowConfig> & Pick<WorkflowConfig, "id" | "name" | "type" | "models">): WorkflowConfig;
-/**
- * Validation result for model configuration
- */
-type ModelConfigValidationResult = {
-    success: boolean;
-    data?: WorkflowModelConfig;
-    error?: z.ZodError;
-};
 /**
  * Validate model configuration
  * @param config - Partial model configuration to validate
  * @returns Validation result with parsed data or error details
  */
-export declare function validateModelConfig(config: Partial<WorkflowModelConfig>): ModelConfigValidationResult;
-/**
- * Validation result for judge configuration
- */
-type JudgeConfigValidationResult = {
-    success: boolean;
-    data?: JudgeConfig;
-    error?: z.ZodError;
-};
+export declare function validateModelConfig(config: Partial<WorkflowModelConfig>): WorkflowValidation<WorkflowModelConfig>;
 /**
  * Validate judge configuration
  * @param config - Partial judge configuration to validate
  * @returns Validation result with parsed data or error details
  */
-export declare function validateJudgeConfig(config: Partial<JudgeConfig>): JudgeConfigValidationResult;
+export declare function validateJudgeConfig(config: Partial<JudgeConfig>): WorkflowValidation<JudgeConfig>;
 /**
  * Check if workflow has judge configuration
  * @param config - Workflow configuration to check
@@ -398,4 +374,3 @@ export declare function getAllJudges(config: WorkflowConfig): JudgeConfig[];
  * @returns Estimated cost in USD
  */
 export declare function estimateWorkflowCost(config: WorkflowConfig, estimatedTokens: number): number;
-export {};

package/dist/lib/workflow/core/ensembleExecutor.js

@@ -7,6 +7,8 @@ import { AIProviderFactory } from "../../core/factory.js";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
 import { WorkflowError } from "../../types/index.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 const functionTag = "EnsembleExecutor";
 // ============================================================================
 // EXECUTION FUNCTIONS
@@ -17,6 +19,16 @@ const functionTag = "EnsembleExecutor";
  * @returns Ensemble execution result with all responses and metrics
  */
 export async function executeEnsemble(options) {
+    return withSpan({
+        name: "neurolink.workflow.ensemble.execute",
+        tracer: tracers.workflow,
+        attributes: {
+            "workflow.model_count": options.models.length,
+            "workflow.parallelism": options.executionConfig?.parallelism ?? 10,
+        },
+    }, async (otelSpan) => executeEnsembleInner(options, otelSpan));
+}
+async function executeEnsembleInner(options, otelSpan) {
     const startTime = Date.now();
     const { prompt, models, executionConfig, systemPrompt, workflowDefaults } = options;
     const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.ensemble", {
@@ -75,6 +87,9 @@ export async function executeEnsemble(options) {
     const spanStatus = successCount > 0 ? SpanStatus.OK : SpanStatus.ERROR;
     const endedSpan = SpanSerializer.endSpan(span, spanStatus, successCount === 0 ? "No successful model responses" : undefined);
     getMetricsAggregator().recordSpan(endedSpan);
+    otelSpan.setAttribute("workflow.success_count", successCount);
+    otelSpan.setAttribute("workflow.failure_count", failureCount);
+    otelSpan.setAttribute("workflow.total_time_ms", totalTime);
     return {
         responses,
         totalTime,
@@ -272,6 +287,16 @@ export function getFastestResponse(responses) {
  * @returns Ensemble execution result with all responses
  */
 export async function executeModelGroups(groups, prompt, _executionConfig, systemPrompt, workflowDefaultSystemPrompt) {
+    return withSpan({
+        name: "neurolink.workflow.layers.execute",
+        tracer: tracers.workflow,
+        attributes: {
+            "workflow.group_count": groups.length,
+            "workflow.total_models": groups.reduce((n, g) => n + g.models.length, 0),
+        },
+    }, async (otelSpan) => executeModelGroupsInner(groups, prompt, _executionConfig, systemPrompt, workflowDefaultSystemPrompt, otelSpan));
+}
+async function executeModelGroupsInner(groups, prompt, _executionConfig, systemPrompt, workflowDefaultSystemPrompt, otelSpan) {
     const startTime = Date.now();
     const allResponses = [];
     const allErrors = [];
@@ -325,6 +350,9 @@ export async function executeModelGroups(groups, prompt, _executionConfig, syste
         successCount: totalSuccessCount,
         failureCount: totalFailureCount,
     });
+    otelSpan.setAttribute("workflow.success_count", totalSuccessCount);
+    otelSpan.setAttribute("workflow.failure_count", totalFailureCount);
+    otelSpan.setAttribute("workflow.total_time_ms", totalTime);
     return {
         responses: allResponses,
         totalTime,

package/dist/lib/workflow/core/judgeScorer.js

@@ -2,9 +2,12 @@
  * workflow/core/judgeScorer.ts
  * Judge-based scoring system for ensemble response evaluation
  */
+import { SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderFactory } from "../../core/factory.js";
 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 { MAX_REASONING_LENGTH } from "../config.js";
 import { WorkflowError } from "../../types/index.js";
 const functionTag = "JudgeScorer";
@@ -17,6 +20,17 @@ const functionTag = "JudgeScorer";
  * @returns Score result with judge evaluation
  */
 export async function scoreEnsemble(options) {
+    return withSpan({
+        name: "neurolink.workflow.judge.score",
+        tracer: tracers.workflow,
+        attributes: {
+            "workflow.judges_count": options.judges.length,
+            "workflow.responses_count": options.responses.length,
+            "workflow.pattern": options.judges.length > 1 ? "multi-judge" : "single-judge",
+        },
+    }, async (otelSpan) => scoreEnsembleInner(options, otelSpan));
+}
+async function scoreEnsembleInner(options, otelSpan) {
     const startTime = Date.now();
     const { judges, responses, originalPrompt, systemPrompt, timeout, workflowDefaults, } = options;
     const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.judge", {
@@ -47,6 +61,7 @@ export async function scoreEnsemble(options) {
             span.durationMs = judgeTime;
             const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
             getMetricsAggregator().recordSpan(endedSpan);
+            otelSpan.setAttribute("workflow.judge_time_ms", judgeTime);
             return {
                 scores: judgeResult,
                 judgeTime,
@@ -59,6 +74,8 @@ export async function scoreEnsemble(options) {
             span.durationMs = judgeTime;
             const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
             getMetricsAggregator().recordSpan(endedSpan);
+            otelSpan.setAttribute("workflow.judge_time_ms", judgeTime);
+            otelSpan.setAttribute("workflow.judges_completed", judges.length);
             return {
                 scores: multiJudgeResult,
                 judgeTime,
@@ -73,6 +90,12 @@ export async function scoreEnsemble(options) {
         span.durationMs = Date.now() - startTime;
         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, err.message);
         getMetricsAggregator().recordSpan(endedSpan);
+        // Mark the outer OTel span as ERROR since we return instead of rethrowing
+        otelSpan.recordException(err);
+        otelSpan.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: err.message,
+        });
         const workflowError = error instanceof WorkflowError
             ? error
             : new WorkflowError(err.message, {

package/dist/lib/workflow/core/responseConditioner.js

@@ -7,6 +7,8 @@
  */
 import { logger } from "../../utils/logger.js";
 import { AIProviderFactory } from "../../core/factory.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 const functionTag = "ResponseConditioner";
 // ============================================================================
 // CONDITIONING FUNCTIONS
@@ -18,6 +20,18 @@ const functionTag = "ResponseConditioner";
  * @returns Conditioned result with synthesized improved content
  */
 export async function conditionResponse(options) {
+    return withSpan({
+        name: "neurolink.workflow.response.condition",
+        tracer: tracers.workflow,
+        attributes: {
+            "workflow.conditioning.enabled": Boolean(options.config?.useConfidence),
+            "workflow.conditioning.has_synthesis_model": Boolean(options.config?.synthesisModel),
+            "workflow.conditioning.original_length": options.content.length,
+            "workflow.conditioning.responses_count": options.allResponses?.length ?? 0,
+        },
+    }, async (otelSpan) => conditionResponseInner(options, otelSpan));
+}
+async function conditionResponseInner(options, otelSpan) {
     const startTime = Date.now();
     const { content, selectedResponse, allResponses, judgeScores, config, originalPrompt, } = options;
     logger.debug(`[${functionTag}] Conditioning response with synthesis`, {
@@ -55,6 +69,9 @@ export async function conditionResponse(options) {
             finalLength: synthesizedContent.length,
             improvement: synthesizedContent.length - content.length,
         });
+        otelSpan.setAttribute("workflow.conditioning.applied", true);
+        otelSpan.setAttribute("workflow.conditioning.synthesis", true);
+        otelSpan.setAttribute("workflow.conditioning.final_length", synthesizedContent.length);
         return {
             content: synthesizedContent,
             conditioningTime,

package/dist/lib/workflow/core/workflowRunner.d.ts

@@ -11,24 +11,7 @@
  *
  * @module workflow/core/workflowRunner
  */
-import type { RunWorkflowOptions, WorkflowConfig, WorkflowResult } from "../../types/index.js";
-/**
- * Progressive workflow response for streaming
- */
-type WorkflowStreamChunk = {
-    /**
-     * Type of response chunk
-     */
-    type: "preliminary" | "final";
-    /**
-     * Response content
-     */
-    content: string;
-    /**
-     * Partial workflow result (only ensemble data for preliminary)
-     */
-    partialResult?: Partial<WorkflowResult>;
-};
+import type { RunWorkflowOptions, WorkflowConfig, WorkflowResult, WorkflowStreamChunk } from "../../types/index.js";
 /**
  * Execute a complete workflow
  *
@@ -76,4 +59,3 @@ export declare function runWorkflow(config: WorkflowConfig, options: RunWorkflow
  * ```
  */
 export declare function runWorkflowWithStreaming(config: WorkflowConfig, options: RunWorkflowOptions): AsyncGenerator<WorkflowStreamChunk, void, undefined>;
-export {};