@mastra/evals 1.1.2-alpha.0 → 1.2.0-alpha.0

package/dist/scorers/code/index.d.ts

@@ -4,4 +4,5 @@ export * from './keyword-coverage/index.js';
 export * from './content-similarity/index.js';
 export * from './tone/index.js';
 export * from './tool-call-accuracy/index.js';
+export * from './trajectory/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/code/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scorers/code/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,QAAQ,CAAC;AACvB,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scorers/code/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,QAAQ,CAAC;AACvB,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}

package/dist/scorers/code/trajectory/index.d.ts

@@ -0,0 +1,147 @@
+import type { ExpectedStep, Trajectory, TrajectoryComparisonOptions, TrajectoryExpectation } from '@mastra/core/evals';
+import type { TrajectoryComparisonResult, TrajectoryEfficiencyResult, TrajectoryBlacklistResult, ToolFailureAnalysisResult } from '../../utils.js';
+interface TrajectoryAccuracyScorerCodeOptions {
+    /**
+     * The expected trajectory to compare against.
+     * Accepts a Trajectory (full trajectory steps) or ExpectedStep[] (lightweight matchers).
+     * If not provided, the scorer will use `run.expectedTrajectory` from the dataset item.
+     */
+    expectedTrajectory?: Trajectory | ExpectedStep[];
+    /** Comparison behavior options */
+    comparisonOptions?: TrajectoryComparisonOptions;
+}
+/**
+ * Creates a code-based trajectory accuracy scorer that compares the actual sequence
+ * of tool calls an agent made against an expected trajectory.
+ *
+ * This scorer extracts the agent's tool call trajectory from its output messages
+ * and compares it against a predefined expected trajectory. It supports strict,
+ * relaxed, and unordered comparison modes.
+ *
+ * @param options - Configuration for the trajectory scorer
+ * @returns A scorer that evaluates trajectory accuracy
+ *
+ * @example
+ * ```ts
+ * import { createTrajectoryAccuracyScorerCode } from '@mastra/evals/scorers';
+ *
+ * const scorer = createTrajectoryAccuracyScorerCode({
+ *   expectedTrajectory: {
+ *     steps: [
+ *       { stepType: 'tool_call', name: 'search' },
+ *       { stepType: 'tool_call', name: 'summarize' },
+ *     ],
+ *   },
+ *   comparisonOptions: {
+ *     ordering: 'relaxed',
+ *     allowRepeatedSteps: true,
+ *   },
+ * });
+ *
+ * const result = await scorer.run(agentRun);
+ * // result.score: 0.0 - 1.0
+ * // result.preprocessStepResult.comparison: detailed comparison results
+ * ```
+ */
+export declare function createTrajectoryAccuracyScorerCode(options?: TrajectoryAccuracyScorerCodeOptions): import("@mastra/core/evals").MastraScorer<"code-trajectory-accuracy-scorer", import("@mastra/core/evals").ScorerRunInputForAgent, Trajectory, Record<"preprocessStepResult", {
+    actualTrajectory: Trajectory;
+    expectedTrajectory: undefined;
+    comparison: undefined;
+    actualStepNames: string[];
+    expectedStepNames: never[];
+    error: string;
+} | {
+    actualTrajectory: Trajectory;
+    expectedTrajectory: {
+        steps: ExpectedStep[];
+    };
+    comparison: TrajectoryComparisonResult;
+    actualStepNames: string[];
+    expectedStepNames: string[];
+    error?: undefined;
+}> & Record<"generateScoreStepResult", number>>;
+/**
+ * Result from evaluating a nested step's children against its TrajectoryExpectation.
+ */
+export type NestedEvaluationResult = {
+    /** Name of the expected step that contained the nested config */
+    stepName: string;
+    /** Score for this nested evaluation (0.0 - 1.0) */
+    score: number;
+    /** Accuracy result for the children */
+    accuracy?: TrajectoryComparisonResult;
+    /** Efficiency result for the children */
+    efficiency?: TrajectoryEfficiencyResult;
+    /** Blacklist result for the children */
+    blacklist?: TrajectoryBlacklistResult;
+    /** Tool failure result for the children */
+    toolFailures?: ToolFailureAnalysisResult;
+    /** Further nested results from deeper levels */
+    nested?: NestedEvaluationResult[];
+};
+/**
+ * Multi-dimensional result from the unified trajectory scorer.
+ */
+export type TrajectoryScoreResult = {
+    /** Overall score (0.0 - 1.0). Weighted combination of dimensions (0.0 if blacklist violation). */
+    score: number;
+    /** Accuracy sub-score (step matching). Only present if expected steps were provided. */
+    accuracy?: TrajectoryComparisonResult;
+    /** Efficiency sub-score (budgets + redundancy). */
+    efficiency?: TrajectoryEfficiencyResult;
+    /** Blacklist sub-score (forbidden tools/sequences). */
+    blacklist?: TrajectoryBlacklistResult;
+    /** Tool failure analysis. */
+    toolFailures?: ToolFailureAnalysisResult;
+    /** Results from evaluating nested step expectations. */
+    nested?: NestedEvaluationResult[];
+};
+interface TrajectoryScorerCodeOptions {
+    /**
+     * Default expectation config for all runs.
+     * Per-item `run.expectedTrajectory` values override these defaults.
+     */
+    defaults?: TrajectoryExpectation;
+}
+/**
+ * Creates a unified trajectory scorer that evaluates multiple dimensions:
+ * accuracy (step matching), efficiency (budgets, redundancy), blacklist (forbidden tools/sequences),
+ * and tool failure patterns.
+ *
+ * Configuration can be set at two levels:
+ * - **Constructor defaults** (`defaults`) — agent-level defaults for all dataset items
+ * - **Per-item overrides** (`run.expectedTrajectory`) — prompt-specific overrides from dataset items
+ *
+ * Per-item values override constructor defaults for all fields.
+ *
+ * @param options - Default trajectory expectations
+ * @returns A scorer with multi-dimensional trajectory evaluation
+ *
+ * @example
+ * ```ts
+ * import { createTrajectoryScorerCode } from '@mastra/evals/scorers';
+ *
+ * const scorer = createTrajectoryScorerCode({
+ *   defaults: {
+ *     steps: [
+ *       { stepType: 'tool_call', name: 'search' },
+ *       { stepType: 'tool_call', name: 'summarize' },
+ *     ],
+ *     ordering: 'relaxed',
+ *     maxSteps: 5,
+ *     noRedundantCalls: true,
+ *     blacklistedTools: ['deleteAll'],
+ *   },
+ * });
+ * ```
+ */
+export declare function createTrajectoryScorerCode(options?: TrajectoryScorerCodeOptions): import("@mastra/core/evals").MastraScorer<"code-trajectory-scorer", import("@mastra/core/evals").ScorerRunInputForAgent, Trajectory, Record<"preprocessStepResult", {
+    accuracy: TrajectoryComparisonResult | undefined;
+    efficiency: TrajectoryEfficiencyResult | undefined;
+    blacklist: TrajectoryBlacklistResult | undefined;
+    toolFailures: ToolFailureAnalysisResult;
+    nested: NestedEvaluationResult[] | undefined;
+    config: TrajectoryExpectation;
+}> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/scorers/code/trajectory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scorers/code/trajectory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,2BAA2B,EAC3B,qBAAqB,EAEtB,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EACV,0BAA0B,EAC1B,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAErB,UAAU,mCAAmC;IAC3C;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,UAAU,GAAG,YAAY,EAAE,CAAC;IACjD,kCAAkC;IAClC,iBAAiB,CAAC,EAAE,2BAA2B,CAAC;CACjD;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,GAAE,mCAAwC;;;;;;;;;;;;;;;;gDAuFnG;AAID;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IACtC,yCAAyC;IACzC,UAAU,CAAC,EAAE,0BAA0B,CAAC;IACxC,wCAAwC;IACxC,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC,2CAA2C;IAC3C,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,gDAAgD;IAChD,MAAM,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACnC,CAAC;AAwJF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,kGAAkG;IAClG,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IACtC,mDAAmD;IACnD,UAAU,CAAC,EAAE,0BAA0B,CAAC;IACxC,uDAAuD;IACvD,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC,6BAA6B;IAC7B,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,wDAAwD;IACxD,MAAM,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACnC,CAAC;AAEF,UAAU,2BAA2B;IACnC;;;OAGG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,2BAAgC;;;;;;;6FAqNnF"}

package/dist/scorers/llm/answer-similarity/index.d.ts

@@ -20,13 +20,13 @@ export declare function createAnswerSimilarityScorer({ model, options, }: {
     matches: {
         groundTruthUnit: string;
         outputUnit: string | null;
-        matchType: "exact" | "semantic" | "partial" | "missing";
+        matchType: "exact" | "partial" | "semantic" | "missing";
         explanation: string;
     }[];
     extraInOutput: string[];
     contradictions: {
-        groundTruthUnit: string;
         outputUnit: string;
+        groundTruthUnit: string;
         explanation: string;
     }[];
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;

package/dist/scorers/llm/context-precision/index.d.ts

@@ -10,9 +10,9 @@ export declare function createContextPrecisionScorer({ model, options, }: {
     options: ContextPrecisionMetricOptions;
 }): import("@mastra/core/evals").MastraScorer<"context-precision-scorer", ScorerRunInputForAgent, ScorerRunOutputForAgent, Record<"analyzeStepResult", {
     verdicts: {
-        reason: string;
-        verdict: string;
         context_index: number;
+        verdict: string;
+        reason: string;
     }[];
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/context-relevance/index.d.ts

@@ -15,11 +15,11 @@ export declare function createContextRelevanceScorerLLM({ model, options, }: {
     options: ContextRelevanceOptions;
 }): import("@mastra/core/evals").MastraScorer<"context-relevance-scorer", ScorerRunInputForAgent, ScorerRunOutputForAgent, Record<"analyzeStepResult", {
     evaluations: {
-        reasoning: string;
         context_index: number;
         contextPiece: string;
         relevanceLevel: "high" | "medium" | "low" | "none";
         wasUsed: boolean;
+        reasoning: string;
     }[];
     overallAssessment: string;
     missingContext?: string[] | undefined;

package/dist/scorers/llm/faithfulness/index.d.ts

@@ -10,8 +10,8 @@ export declare function createFaithfulnessScorer({ model, options, }: {
     claims: string[];
 }> & Record<"analyzeStepResult", {
     verdicts: {
-        reason: string;
         verdict: string;
+        reason: string;
     }[];
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/hallucination/index.d.ts

@@ -27,9 +27,9 @@ export declare function createHallucinationScorer({ model, options, }: {
     claims: string[];
 }> & Record<"analyzeStepResult", {
     verdicts: {
-        reason: string;
-        verdict: string;
         statement: string;
+        verdict: string;
+        reason: string;
     }[];
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/index.d.ts

@@ -9,4 +9,5 @@ export * from './context-relevance/index.js';
 export * from './context-precision/index.js';
 export * from './noise-sensitivity/index.js';
 export * from './prompt-alignment/index.js';
+export * from './trajectory/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scorers/llm/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scorers/llm/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/dist/scorers/llm/noise-sensitivity/index.d.ts

@@ -22,13 +22,13 @@ export declare function createNoiseSensitivityScorerLLM({ model, options, }: {
     model: MastraModelConfig;
     options: NoiseSensitivityOptions;
 }): import("@mastra/core/evals").MastraScorer<"noise-sensitivity-scorer", import("@mastra/core/evals").ScorerRunInputForAgent, import("@mastra/core/evals").ScorerRunOutputForAgent, Record<"analyzeStepResult", {
-    overallAssessment: string;
     dimensions: {
         dimension: string;
         impactLevel: "none" | "minimal" | "moderate" | "significant" | "severe";
         specificChanges: string;
         noiseInfluence: string;
     }[];
+    overallAssessment: string;
     robustnessScore: number;
     majorIssues?: string[] | undefined;
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;

package/dist/scorers/llm/prompt-alignment/index.d.ts

@@ -8,31 +8,31 @@ export declare function createPromptAlignmentScorerLLM({ model, options, }: {
     model: MastraModelConfig;
     options?: PromptAlignmentOptions;
 }): import("@mastra/core/evals").MastraScorer<string, ScorerRunInputForAgent, ScorerRunOutputForAgent, Record<"analyzeStepResult", {
-    overallAssessment: string;
     intentAlignment: {
-        reasoning: string;
         score: number;
         primaryIntent: string;
         isAddressed: boolean;
+        reasoning: string;
     };
     requirementsFulfillment: {
         requirements: {
-            reasoning: string;
             requirement: string;
             isFulfilled: boolean;
+            reasoning: string;
         }[];
         overallScore: number;
     };
     completeness: {
-        reasoning: string;
         score: number;
         missingElements: string[];
+        reasoning: string;
     };
     responseAppropriateness: {
-        reasoning: string;
         score: number;
         formatAlignment: boolean;
         toneAlignment: boolean;
+        reasoning: string;
     };
+    overallAssessment: string;
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/tool-call-accuracy/index.d.ts

@@ -10,9 +10,9 @@ export declare function createToolCallAccuracyScorerLLM({ model, availableTools
     toolCallInfos: import("../..").ToolCallInfo[];
 }> & Record<"analyzeStepResult", {
     evaluations: {
-        reasoning: string;
         toolCalled: string;
         wasAppropriate: boolean;
+        reasoning: string;
     }[];
     missingTools?: string[] | undefined;
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;

package/dist/scorers/llm/toxicity/index.d.ts

@@ -7,8 +7,8 @@ export declare function createToxicityScorer({ model, options, }: {
     options?: ToxicityMetricOptions;
 }): import("@mastra/core/evals").MastraScorer<"toxicity-scorer", import("@mastra/core/evals").ScorerRunInputForAgent, import("@mastra/core/evals").ScorerRunOutputForAgent, Record<"analyzeStepResult", {
     verdicts: {
-        reason: string;
         verdict: string;
+        reason: string;
     }[];
 }> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/trajectory/index.d.ts

@@ -0,0 +1,58 @@
+import type { ExpectedStep, Trajectory } from '@mastra/core/evals';
+import type { MastraModelConfig } from '@mastra/core/llm';
+export interface TrajectoryAccuracyLLMOptions {
+    /** The LLM model to use as judge */
+    model: MastraModelConfig;
+    /** Optional expected trajectory to compare against */
+    expectedTrajectory?: Trajectory | ExpectedStep[];
+}
+/**
+ * Creates an LLM-based trajectory accuracy scorer that evaluates the quality
+ * of an agent's action sequence using an LLM judge.
+ *
+ * This scorer extracts the agent's tool call trajectory and asks an LLM to evaluate
+ * whether the trajectory was appropriate, efficient, and complete. When an expected
+ * trajectory is provided, it compares against it. Otherwise, it evaluates the trajectory
+ * based on the task requirements.
+ *
+ * @param options - Configuration for the trajectory scorer
+ * @returns A scorer that evaluates trajectory quality
+ *
+ * @example
+ * ```ts
+ * import { createTrajectoryAccuracyScorerLLM } from '@mastra/evals/scorers';
+ *
+ * // Without expected trajectory (evaluates quality based on task)
+ * const scorer = createTrajectoryAccuracyScorerLLM({
+ *   model: { provider: 'openai', name: 'gpt-4o' },
+ * });
+ *
+ * // With expected trajectory
+ * const scorerWithExpected = createTrajectoryAccuracyScorerLLM({
+ *   model: { provider: 'openai', name: 'gpt-4o' },
+ *   expectedTrajectory: {
+ *     steps: [
+ *       { stepType: 'tool_call', name: 'search' },
+ *       { stepType: 'tool_call', name: 'summarize' },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export declare function createTrajectoryAccuracyScorerLLM({ model, expectedTrajectory: staticExpectedTrajectory, }: TrajectoryAccuracyLLMOptions): import("@mastra/core/evals").MastraScorer<"llm-trajectory-accuracy-scorer", import("@mastra/core/evals").ScorerRunInputForAgent, Trajectory, Record<"preprocessStepResult", {
+    actualTrajectory: Trajectory;
+    actualTrajectoryFormatted: string;
+    expectedTrajectoryFormatted: string | undefined;
+    hasSteps: boolean;
+}> & Record<"analyzeStepResult", {
+    stepEvaluations: {
+        stepName: string;
+        wasNecessary: boolean;
+        wasInOrder: boolean;
+        reasoning: string;
+    }[];
+    overallAssessment: string;
+    missingSteps?: string[] | undefined;
+    extraSteps?: string[] | undefined;
+}> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/scorers/llm/trajectory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scorers/llm/trajectory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAyC,MAAM,oBAAoB,CAAC;AAE1G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAK1D,MAAM,WAAW,4BAA4B;IAC3C,oCAAoC;IACpC,KAAK,EAAE,iBAAiB,CAAC;IACzB,sDAAsD;IACtD,kBAAkB,CAAC,EAAE,UAAU,GAAG,YAAY,EAAE,CAAC;CAClD;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iCAAiC,CAAC,EAChD,KAAK,EACL,kBAAkB,EAAE,wBAAwB,GAC7C,EAAE,4BAA4B;;;;;;;;;;;;;;;6FA+G9B"}

package/dist/scorers/llm/trajectory/prompts.d.ts

@@ -0,0 +1,20 @@
+export declare const TRAJECTORY_EVALUATION_INSTRUCTIONS = "\nYou are an expert evaluator specializing in AI agent trajectory analysis. Your role is to assess whether an agent took an appropriate sequence of actions (tool calls, reasoning steps) to accomplish a user's request.\n\nCORE RESPONSIBILITIES:\n- Analyze the full sequence of actions the agent took\n- Evaluate whether each step was necessary and well-ordered\n- Identify unnecessary, redundant, or missing steps\n- Assess the overall quality of the agent's action path\n\nEVALUATION PHILOSOPHY:\n- Consider both the individual steps AND the overall flow\n- A good trajectory is efficient, logical, and complete\n- Redundant steps reduce quality even if the final result is correct\n- Missing critical steps are a significant issue\n- Order matters: logical dependencies should be respected\n\nOUTPUT REQUIREMENTS:\n- Provide clear reasoning for your trajectory assessment\n- Use provided JSON schema exactly as specified\n- Be consistent in your evaluation standards\n";
+export declare const createAnalyzePrompt: ({ userInput, agentResponse, actualTrajectory, expectedTrajectory, }: {
+    userInput: string;
+    agentResponse: string;
+    actualTrajectory: string;
+    expectedTrajectory?: string;
+}) => string;
+export declare const createReasonPrompt: ({ userInput, score, stepEvaluations, missingSteps, extraSteps, }: {
+    userInput: string;
+    score: number;
+    stepEvaluations: Array<{
+        stepName: string;
+        wasNecessary: boolean;
+        wasInOrder: boolean;
+        reasoning: string;
+    }>;
+    missingSteps: string[];
+    extraSteps: string[];
+}) => string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/scorers/llm/trajectory/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../src/scorers/llm/trajectory/prompts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kCAAkC,88BAoB9C,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,qEAKjC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,KAAG,MA2CH,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,kEAMhC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5G,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,KAAG,MAYH,CAAC"}