@juspay/neurolink 9.36.1 → 9.38.0

package/dist/evaluation/EvaluatorRegistry.js

@@ -0,0 +1,184 @@
+/**
+ * @file EvaluatorRegistry - Registry for evaluation strategies.
+ * Extends BaseRegistry to provide dynamic strategy registration and lookup.
+ */
+import { BaseRegistry } from "../core/infrastructure/index.js";
+import { createStrategyNotFoundError } from "./errors/EvaluationError.js";
+import { withTimeout, ErrorFactory } from "../utils/errorHandling.js";
+/**
+ * Registry for evaluation strategies.
+ * Allows dynamic registration and retrieval of evaluation strategies.
+ *
+ * @example
+ * ```typescript
+ * // Register a custom strategy
+ * EvaluatorRegistry.getInstance().registerStrategy(
+ *   'custom-ragas',
+ *   async () => ({
+ *     evaluate: async (options, result) => { ... }
+ *   }),
+ *   {
+ *     name: 'Custom RAGAS',
+ *     description: 'Custom RAGAS implementation',
+ *     requiresLLM: true,
+ *     defaultModel: 'gpt-4',
+ *     defaultProvider: 'openai',
+ *     version: '1.0.0',
+ *     features: ['custom-metrics']
+ *   }
+ * );
+ *
+ * // Get a strategy
+ * const strategy = await EvaluatorRegistry.getInstance().getStrategy('ragas');
+ * ```
+ */
+export class EvaluatorRegistry extends BaseRegistry {
+    static instance = null;
+    constructor() {
+        super();
+    }
+    /**
+     * Gets the singleton instance of the EvaluatorRegistry.
+     */
+    static getInstance() {
+        if (!EvaluatorRegistry.instance) {
+            EvaluatorRegistry.instance = new EvaluatorRegistry();
+        }
+        return EvaluatorRegistry.instance;
+    }
+    /**
+     * Resets the singleton instance (useful for testing).
+     */
+    static resetInstance() {
+        EvaluatorRegistry.instance = null;
+    }
+    /**
+     * Registers all built-in evaluation strategies.
+     * This is called automatically on first access.
+     */
+    async registerAll() {
+        // Register the built-in RAGAS strategy
+        this.registerStrategy("ragas", async () => {
+            const { RAGASEvaluator } = await import("./ragasEvaluator.js");
+            const { ContextBuilder } = await import("./contextBuilder.js");
+            return async (options, result, config) => {
+                const contextBuilder = new ContextBuilder();
+                const ragasEvaluator = new RAGASEvaluator(config?.evaluationModel, config?.provider, config?.threshold, config?.promptGenerator);
+                const evalContext = contextBuilder.buildContext(options, result);
+                const evaluationTimeoutMs = config?.options?.timeout ?? 60000;
+                const evaluationResult = await withTimeout(ragasEvaluator.evaluate(evalContext), evaluationTimeoutMs, ErrorFactory.evaluationTimeout("strategy evaluation", evaluationTimeoutMs));
+                return { evaluationResult, evalContext };
+            };
+        }, {
+            name: "RAGAS Evaluator",
+            description: "RAGAS-style LLM-as-judge evaluation with relevance, accuracy, and completeness metrics",
+            requiresLLM: true,
+            defaultModel: "gemini-1.5-flash",
+            defaultProvider: "vertex",
+            version: "1.0.0",
+            features: [
+                "relevance-scoring",
+                "accuracy-scoring",
+                "completeness-scoring",
+                "reasoning",
+                "suggestions",
+            ],
+        });
+    }
+    /**
+     * Registers an evaluation strategy with the registry.
+     *
+     * @param id - Unique identifier for the strategy
+     * @param factory - Factory function that creates the strategy
+     * @param metadata - Metadata about the strategy
+     */
+    registerStrategy(id, factory, metadata) {
+        this.register(id, factory, [], { metadata });
+    }
+    /**
+     * Gets an evaluation strategy by ID.
+     *
+     * @param id - The strategy identifier
+     * @returns The evaluation strategy function
+     * @throws {NeuroLinkFeatureError} If the strategy is not found
+     */
+    async getStrategy(id) {
+        const strategy = await this.get(id);
+        if (!strategy) {
+            const strategies = await this.listStrategies();
+            const available = strategies.map((s) => s.id);
+            throw createStrategyNotFoundError(id, available);
+        }
+        return strategy;
+    }
+    /**
+     * Checks if a strategy exists in the registry.
+     *
+     * @param id - The strategy identifier
+     * @returns true if the strategy exists
+     */
+    async hasStrategy(id) {
+        await this.ensureInitialized();
+        return this.has(id);
+    }
+    /**
+     * Lists all registered strategies with their metadata.
+     *
+     * @returns Array of strategy IDs and their metadata
+     */
+    async listStrategies() {
+        await this.ensureInitialized();
+        return this.list();
+    }
+    /**
+     * Gets the metadata for a specific strategy.
+     *
+     * @param id - The strategy identifier
+     * @returns The strategy metadata or undefined if not found
+     */
+    async getStrategyMetadata(id) {
+        await this.ensureInitialized();
+        const entry = this.items.get(id);
+        return entry?.metadata;
+    }
+    /**
+     * Unregisters a strategy from the registry.
+     *
+     * @param id - The strategy identifier
+     * @returns true if the strategy was removed, false if it didn't exist
+     */
+    async unregisterStrategy(id) {
+        await this.ensureInitialized();
+        if (this.items.has(id)) {
+            this.items.delete(id);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Gets strategies that support a specific feature.
+     *
+     * @param feature - The feature to filter by
+     * @returns Array of strategy IDs that support the feature
+     */
+    async getStrategiesWithFeature(feature) {
+        await this.ensureInitialized();
+        return this.list()
+            .filter((item) => item.metadata.features.includes(feature))
+            .map((item) => item.id);
+    }
+    /**
+     * Gets strategies that use a specific provider.
+     *
+     * @param provider - The provider to filter by
+     * @returns Array of strategy IDs that use the provider
+     */
+    async getStrategiesByProvider(provider) {
+        await this.ensureInitialized();
+        return this.list()
+            .filter((item) => item.metadata.defaultProvider === provider)
+            .map((item) => item.id);
+    }
+}
+// Export singleton instance getter for convenience
+export const getEvaluatorRegistry = () => EvaluatorRegistry.getInstance();

package/dist/evaluation/errors/EvaluationError.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @file Typed error hierarchy for the Evaluation/Scoring System.
+ * Uses NeuroLinkFeatureError and createErrorFactory from core infrastructure.
+ */
+import { NeuroLinkFeatureError } from "../../core/infrastructure/index.js";
+import type { EnhancedEvaluationContext } from "../../types/evaluationTypes.js";
+/**
+ * Error codes for the Evaluation feature.
+ * These codes help identify specific error scenarios for proper handling.
+ */
+export declare const EvaluationErrorCodes: {
+    /** The evaluation process itself failed */
+    readonly EVALUATION_FAILED: "EVALUATION_FAILED";
+    /** Failed to parse the evaluation response from the judge LLM */
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    /** The requested evaluation strategy was not found in the registry */
+    readonly STRATEGY_NOT_FOUND: "STRATEGY_NOT_FOUND";
+    /** The AI provider for evaluation failed */
+    readonly PROVIDER_ERROR: "PROVIDER_ERROR";
+    /** Configuration for evaluation is invalid or missing */
+    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+    /** The custom evaluator function threw an error */
+    readonly CUSTOM_EVALUATOR_ERROR: "CUSTOM_EVALUATOR_ERROR";
+    /** Batch evaluation failed for one or more items */
+    readonly BATCH_EVALUATION_ERROR: "BATCH_EVALUATION_ERROR";
+    /** Aggregation of evaluation results failed */
+    readonly AGGREGATION_ERROR: "AGGREGATION_ERROR";
+    /** Registry operation failed */
+    readonly REGISTRY_ERROR: "REGISTRY_ERROR";
+    /** Maximum retry attempts exceeded */
+    readonly MAX_RETRIES_EXCEEDED: "MAX_RETRIES_EXCEEDED";
+    /** Timeout during evaluation */
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    /** Rate limit hit during evaluation */
+    readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
+};
+/**
+ * Type for evaluation error codes
+ */
+export type EvaluationErrorCode = (typeof EvaluationErrorCodes)[keyof typeof EvaluationErrorCodes];
+/**
+ * Factory for creating typed evaluation errors.
+ * Uses the createErrorFactory pattern from core infrastructure.
+ */
+export declare const evaluationErrors: {
+    codes: {
+        /** The evaluation process itself failed */
+        readonly EVALUATION_FAILED: "EVALUATION_FAILED";
+        /** Failed to parse the evaluation response from the judge LLM */
+        readonly PARSE_ERROR: "PARSE_ERROR";
+        /** The requested evaluation strategy was not found in the registry */
+        readonly STRATEGY_NOT_FOUND: "STRATEGY_NOT_FOUND";
+        /** The AI provider for evaluation failed */
+        readonly PROVIDER_ERROR: "PROVIDER_ERROR";
+        /** Configuration for evaluation is invalid or missing */
+        readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+        /** The custom evaluator function threw an error */
+        readonly CUSTOM_EVALUATOR_ERROR: "CUSTOM_EVALUATOR_ERROR";
+        /** Batch evaluation failed for one or more items */
+        readonly BATCH_EVALUATION_ERROR: "BATCH_EVALUATION_ERROR";
+        /** Aggregation of evaluation results failed */
+        readonly AGGREGATION_ERROR: "AGGREGATION_ERROR";
+        /** Registry operation failed */
+        readonly REGISTRY_ERROR: "REGISTRY_ERROR";
+        /** Maximum retry attempts exceeded */
+        readonly MAX_RETRIES_EXCEEDED: "MAX_RETRIES_EXCEEDED";
+        /** Timeout during evaluation */
+        readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+        /** Rate limit hit during evaluation */
+        readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
+    };
+    create: (code: "PROVIDER_ERROR" | "CONFIGURATION_ERROR" | "EVALUATION_FAILED" | "PARSE_ERROR" | "STRATEGY_NOT_FOUND" | "CUSTOM_EVALUATOR_ERROR" | "BATCH_EVALUATION_ERROR" | "AGGREGATION_ERROR" | "REGISTRY_ERROR" | "MAX_RETRIES_EXCEEDED" | "TIMEOUT_ERROR" | "RATE_LIMIT_ERROR", message: string, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    } | undefined) => NeuroLinkFeatureError;
+};
+/**
+ * Extended evaluation context for error details.
+ * Provides rich debugging information when errors occur.
+ */
+export interface EvaluationErrorContext {
+    /** Length of the user query (redacted for safety) */
+    userQueryLength?: number;
+    /** Length of the AI response (redacted for safety) */
+    aiResponseLength?: number;
+    /** The current attempt number */
+    attemptNumber?: number;
+    /** Previous evaluation scores if any */
+    previousScores?: number[];
+    /** The evaluation strategy in use */
+    strategy?: string;
+    /** The evaluation model being used */
+    evaluationModel?: string;
+    /** The provider being used */
+    provider?: string;
+    /** Length of the raw response (redacted for safety) */
+    rawResponseLength?: number;
+    /** Any additional context */
+    additionalContext?: Record<string, unknown>;
+}
+/**
+ * Checks if an error is retryable based on its code.
+ * Transient errors (timeout, rate limit, some provider errors) are retryable.
+ *
+ * @param error - The error to check
+ * @returns true if the error is retryable
+ */
+export declare function isRetryableEvaluationError(error: NeuroLinkFeatureError): boolean;
+/**
+ * Checks if an error is a NeuroLinkFeatureError from the Evaluation feature.
+ *
+ * @param error - The error to check
+ * @returns true if the error is an evaluation error
+ */
+export declare function isEvaluationError(error: unknown): error is NeuroLinkFeatureError;
+/**
+ * Helper function to create an evaluation failed error with context.
+ *
+ * @param message - The error message
+ * @param context - The evaluation context
+ * @param cause - The underlying cause error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createEvaluationFailedError(message: string, context?: EvaluationErrorContext, cause?: Error): NeuroLinkFeatureError;
+/**
+ * Helper function to create a parse error with raw response.
+ *
+ * @param rawResponse - The raw response that failed to parse
+ * @param cause - The underlying parse error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createParseError(rawResponse: string, cause?: Error): NeuroLinkFeatureError;
+/**
+ * Helper function to create a strategy not found error.
+ *
+ * @param strategyName - The name of the strategy that was not found
+ * @param availableStrategies - List of available strategies
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createStrategyNotFoundError(strategyName: string, availableStrategies?: string[]): NeuroLinkFeatureError;
+/**
+ * Helper function to create a provider error.
+ *
+ * @param message - The error message
+ * @param provider - The provider that failed
+ * @param cause - The underlying cause error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createProviderError(message: string, provider: string, cause?: Error, options?: {
+    retryable?: boolean;
+}): NeuroLinkFeatureError;
+/**
+ * Helper function to create a max retries exceeded error.
+ *
+ * @param attempts - The number of attempts made
+ * @param lastScore - The last evaluation score
+ * @param threshold - The passing threshold
+ * @param context - The evaluation context
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createMaxRetriesExceededError(attempts: number, lastScore: number, threshold: number, context?: EvaluationErrorContext): NeuroLinkFeatureError;
+/**
+ * Helper function to create a batch evaluation error.
+ *
+ * @param failedCount - Number of evaluations that failed
+ * @param totalCount - Total number of evaluations attempted
+ * @param errors - Array of individual errors
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createBatchEvaluationError(failedCount: number, totalCount: number, errors: Array<{
+    index: number;
+    error: Error;
+}>): NeuroLinkFeatureError;
+/**
+ * Helper function to create a configuration error.
+ *
+ * @param message - The error message
+ * @param configIssue - Description of the configuration issue
+ * @returns A typed NeuroLinkFeatureError
+ */
+export declare function createConfigurationError(message: string, configIssue: string): NeuroLinkFeatureError;
+/**
+ * Converts an evaluation context to error context for debugging.
+ *
+ * @param context - The enhanced evaluation context
+ * @returns An EvaluationErrorContext
+ */
+export declare function contextToErrorContext(context: EnhancedEvaluationContext): EvaluationErrorContext;

package/dist/evaluation/errors/EvaluationError.js

@@ -0,0 +1,206 @@
+/**
+ * @file Typed error hierarchy for the Evaluation/Scoring System.
+ * Uses NeuroLinkFeatureError and createErrorFactory from core infrastructure.
+ */
+import { NeuroLinkFeatureError, createErrorFactory, } from "../../core/infrastructure/index.js";
+/**
+ * Error codes for the Evaluation feature.
+ * These codes help identify specific error scenarios for proper handling.
+ */
+export const EvaluationErrorCodes = {
+    /** The evaluation process itself failed */
+    EVALUATION_FAILED: "EVALUATION_FAILED",
+    /** Failed to parse the evaluation response from the judge LLM */
+    PARSE_ERROR: "PARSE_ERROR",
+    /** The requested evaluation strategy was not found in the registry */
+    STRATEGY_NOT_FOUND: "STRATEGY_NOT_FOUND",
+    /** The AI provider for evaluation failed */
+    PROVIDER_ERROR: "PROVIDER_ERROR",
+    /** Configuration for evaluation is invalid or missing */
+    CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
+    /** The custom evaluator function threw an error */
+    CUSTOM_EVALUATOR_ERROR: "CUSTOM_EVALUATOR_ERROR",
+    /** Batch evaluation failed for one or more items */
+    BATCH_EVALUATION_ERROR: "BATCH_EVALUATION_ERROR",
+    /** Aggregation of evaluation results failed */
+    AGGREGATION_ERROR: "AGGREGATION_ERROR",
+    /** Registry operation failed */
+    REGISTRY_ERROR: "REGISTRY_ERROR",
+    /** Maximum retry attempts exceeded */
+    MAX_RETRIES_EXCEEDED: "MAX_RETRIES_EXCEEDED",
+    /** Timeout during evaluation */
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    /** Rate limit hit during evaluation */
+    RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR",
+};
+/**
+ * Factory for creating typed evaluation errors.
+ * Uses the createErrorFactory pattern from core infrastructure.
+ */
+export const evaluationErrors = createErrorFactory("Evaluation", EvaluationErrorCodes);
+/**
+ * Checks if an error is retryable based on its code.
+ * Transient errors (timeout, rate limit, some provider errors) are retryable.
+ *
+ * @param error - The error to check
+ * @returns true if the error is retryable
+ */
+export function isRetryableEvaluationError(error) {
+    if (error.retryable) {
+        return true;
+    }
+    const retryableCodes = [
+        EvaluationErrorCodes.TIMEOUT_ERROR,
+        EvaluationErrorCodes.RATE_LIMIT_ERROR,
+    ];
+    return retryableCodes.includes(error.code);
+}
+/**
+ * Checks if an error is a NeuroLinkFeatureError from the Evaluation feature.
+ *
+ * @param error - The error to check
+ * @returns true if the error is an evaluation error
+ */
+export function isEvaluationError(error) {
+    return (error instanceof NeuroLinkFeatureError && error.feature === "Evaluation");
+}
+/**
+ * Helper function to create an evaluation failed error with context.
+ *
+ * @param message - The error message
+ * @param context - The evaluation context
+ * @param cause - The underlying cause error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createEvaluationFailedError(message, context, cause) {
+    return evaluationErrors.create("EVALUATION_FAILED", message, {
+        retryable: false,
+        details: {
+            evaluationContext: context,
+        },
+        cause,
+    });
+}
+/**
+ * Helper function to create a parse error with raw response.
+ *
+ * @param rawResponse - The raw response that failed to parse
+ * @param cause - The underlying parse error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createParseError(rawResponse, cause) {
+    return evaluationErrors.create("PARSE_ERROR", "Failed to parse evaluation response from judge LLM", {
+        retryable: false,
+        details: {
+            rawResponseLength: rawResponse.length,
+        },
+        cause,
+    });
+}
+/**
+ * Helper function to create a strategy not found error.
+ *
+ * @param strategyName - The name of the strategy that was not found
+ * @param availableStrategies - List of available strategies
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createStrategyNotFoundError(strategyName, availableStrategies = []) {
+    return evaluationErrors.create("STRATEGY_NOT_FOUND", `Evaluation strategy "${strategyName}" not found in registry`, {
+        retryable: false,
+        details: {
+            requestedStrategy: strategyName,
+            availableStrategies,
+        },
+    });
+}
+/**
+ * Helper function to create a provider error.
+ *
+ * @param message - The error message
+ * @param provider - The provider that failed
+ * @param cause - The underlying cause error
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createProviderError(message, provider, cause, options) {
+    return evaluationErrors.create("PROVIDER_ERROR", message, {
+        retryable: options?.retryable ?? false,
+        details: {
+            provider,
+            errorMessage: cause?.message,
+        },
+        cause,
+    });
+}
+/**
+ * Helper function to create a max retries exceeded error.
+ *
+ * @param attempts - The number of attempts made
+ * @param lastScore - The last evaluation score
+ * @param threshold - The passing threshold
+ * @param context - The evaluation context
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createMaxRetriesExceededError(attempts, lastScore, threshold, context) {
+    return evaluationErrors.create("MAX_RETRIES_EXCEEDED", `Maximum retry attempts (${attempts}) exceeded. Last score: ${lastScore}, threshold: ${threshold}`, {
+        retryable: false,
+        details: {
+            attempts,
+            lastScore,
+            threshold,
+            evaluationContext: context,
+        },
+    });
+}
+/**
+ * Helper function to create a batch evaluation error.
+ *
+ * @param failedCount - Number of evaluations that failed
+ * @param totalCount - Total number of evaluations attempted
+ * @param errors - Array of individual errors
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createBatchEvaluationError(failedCount, totalCount, errors) {
+    return evaluationErrors.create("BATCH_EVALUATION_ERROR", `Batch evaluation failed: ${failedCount} of ${totalCount} evaluations failed`, {
+        retryable: false,
+        details: {
+            failedCount,
+            totalCount,
+            successCount: totalCount - failedCount,
+            errors: errors.map((e) => ({
+                index: e.index,
+                message: e.error.message,
+            })),
+        },
+    });
+}
+/**
+ * Helper function to create a configuration error.
+ *
+ * @param message - The error message
+ * @param configIssue - Description of the configuration issue
+ * @returns A typed NeuroLinkFeatureError
+ */
+export function createConfigurationError(message, configIssue) {
+    return evaluationErrors.create("CONFIGURATION_ERROR", message, {
+        retryable: false,
+        details: {
+            configIssue,
+        },
+    });
+}
+/**
+ * Converts an evaluation context to error context for debugging.
+ *
+ * @param context - The enhanced evaluation context
+ * @returns An EvaluationErrorContext
+ */
+export function contextToErrorContext(context) {
+    return {
+        userQueryLength: context.userQuery?.length,
+        aiResponseLength: context.aiResponse?.length,
+        attemptNumber: context.attemptNumber,
+        previousScores: context.previousEvaluations?.map((e) => e.finalScore),
+        evaluationModel: undefined, // Will be set by the evaluator
+        provider: context.provider,
+    };
+}

package/dist/evaluation/errors/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file Exports all evaluation error types and utilities.
+ */
+export { EvaluationErrorCodes, type EvaluationErrorCode, evaluationErrors, type EvaluationErrorContext, isRetryableEvaluationError, isEvaluationError, createEvaluationFailedError, createParseError, createStrategyNotFoundError, createProviderError, createMaxRetriesExceededError, createBatchEvaluationError, createConfigurationError, contextToErrorContext, } from "./EvaluationError.js";

package/dist/evaluation/errors/index.js

@@ -0,0 +1,4 @@
+/**
+ * @file Exports all evaluation error types and utilities.
+ */
+export { EvaluationErrorCodes, evaluationErrors, isRetryableEvaluationError, isEvaluationError, createEvaluationFailedError, createParseError, createStrategyNotFoundError, createProviderError, createMaxRetriesExceededError, createBatchEvaluationError, createConfigurationError, contextToErrorContext, } from "./EvaluationError.js";

package/dist/evaluation/hooks/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Hooks Index
+ * Export all observability hooks
+ */
+export { createLangfuseAdapter, createMockLangfuseClient, LangfuseAdapter, type LangfuseAdapterConfig, type LangfuseClient, startLangfuseAdapter, } from "./langfuseAdapter.js";
+export { createConsoleLoggerHook, createMetricsCollectorHook, type EvaluationEvents, type EventHandler, ObservabilityHooks, observabilityHooks, pipelineToSpanAttributes, type SpanAttributes, scorerToSpanAttributes, } from "./observabilityHooks.js";

package/dist/evaluation/hooks/index.js

@@ -0,0 +1,6 @@
+/**
+ * @file Hooks Index
+ * Export all observability hooks
+ */
+export { createLangfuseAdapter, createMockLangfuseClient, LangfuseAdapter, startLangfuseAdapter, } from "./langfuseAdapter.js";
+export { createConsoleLoggerHook, createMetricsCollectorHook, ObservabilityHooks, observabilityHooks, pipelineToSpanAttributes, scorerToSpanAttributes, } from "./observabilityHooks.js";