chore: import upstream snapshot with attribution

test/assertions/trajectoryGoalSuccess.test.ts

@@ -0,0 +1,264 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleTrajectoryGoalSuccess } from '../../src/assertions/trajectory';
+import { matchesTrajectoryGoalSuccess } from '../../src/matchers/llmGrading';
+import { createMockProvider, createProviderResponse } from '../factories/provider';
+
+import type { AssertionParams, AtomicTestCase, GradingResult } from '../../src/types/index';
+import type { TraceData } from '../../src/types/tracing';
+
+vi.mock('../../src/matchers/llmGrading', async () => {
+  const actual = await vi.importActual<typeof import('../../src/matchers/llmGrading')>(
+    '../../src/matchers/llmGrading',
+  );
+  return {
+    ...actual,
+    matchesTrajectoryGoalSuccess: vi.fn(),
+  };
+});
+
+const mockProvider = createMockProvider({
+  id: 'mock',
+  response: createProviderResponse({ output: 'mock' }),
+});
+
+const mockTraceData: TraceData = {
+  traceId: 'test-trace-id',
+  evaluationId: 'test-evaluation-id',
+  testCaseId: 'test-test-case-id',
+  metadata: { test: 'value' },
+  spans: [
+    {
+      spanId: 'span-1',
+      name: 'chat gpt-5',
+      startTime: 1000,
+      endTime: 1800,
+      attributes: {
+        'promptfoo.provider.id': 'openai:gpt-5',
+      },
+    },
+    {
+      spanId: 'span-2',
+      name: 'tool.call',
+      startTime: 1100,
+      endTime: 1200,
+      attributes: {
+        'tool.name': 'search_orders',
+      },
+    },
+    {
+      spanId: 'span-3',
+      name: 'tool.call',
+      startTime: 1400,
+      endTime: 1500,
+      attributes: {
+        'tool.name': 'compose_reply',
+      },
+    },
+  ],
+};
+
+const defaultParams: AssertionParams = {
+  assertion: {
+    type: 'trajectory:goal-success',
+    value: 'Resolve the order lookup task',
+  },
+  baseType: 'trajectory:goal-success',
+  assertionValueContext: {
+    vars: {},
+    test: {} as AtomicTestCase,
+    prompt: 'test prompt',
+    logProbs: undefined,
+    provider: mockProvider,
+    providerResponse: { output: 'test output' },
+    trace: mockTraceData,
+  },
+  output: 'test output',
+  outputString: 'test output',
+  providerResponse: { output: 'test output' },
+  test: {} as AtomicTestCase,
+  inverse: false,
+};
+
+describe('handleTrajectoryGoalSuccess', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('passes the goal, summarized trajectory, and provider context to the matcher', async () => {
+    const expectedResult: GradingResult = {
+      pass: true,
+      score: 0.9,
+      reason: 'Goal achieved',
+    };
+    vi.mocked(matchesTrajectoryGoalSuccess).mockResolvedValue(expectedResult);
+
+    const providerCallContext = {
+      originalProvider: mockProvider,
+      prompt: { raw: 'test prompt', label: 'test prompt' },
+      vars: { orderId: '123' },
+    };
+
+    const params: AssertionParams = {
+      ...defaultParams,
+      assertionValueContext: {
+        ...defaultParams.assertionValueContext,
+        vars: { orderId: '123' },
+      },
+      providerCallContext,
+      test: {
+        vars: { orderId: '123' },
+      },
+    };
+
+    const result = await handleTrajectoryGoalSuccess(params);
+
+    expect(result).toEqual(expectedResult);
+    expect(matchesTrajectoryGoalSuccess).toHaveBeenCalledWith(
+      'Resolve the order lookup task',
+      expect.stringContaining('"stepCount": 3'),
+      'test output',
+      undefined,
+      { orderId: '123' },
+      params.assertion,
+      providerCallContext,
+    );
+    expect(vi.mocked(matchesTrajectoryGoalSuccess).mock.calls[0]?.[1]).toContain('search_orders');
+    expect(vi.mocked(matchesTrajectoryGoalSuccess).mock.calls[0]?.[1]).toContain('compose_reply');
+  });
+
+  it('accepts an object value with a goal property', async () => {
+    const expectedResult: GradingResult = {
+      pass: false,
+      score: 0.2,
+      reason: 'Goal not achieved',
+    };
+    vi.mocked(matchesTrajectoryGoalSuccess).mockResolvedValue(expectedResult);
+
+    const params: AssertionParams = {
+      ...defaultParams,
+      assertion: {
+        type: 'trajectory:goal-success',
+        value: {
+          goal: 'Send the user a confirmed shipping status',
+        },
+      },
+      renderedValue: {
+        goal: 'Send the user a confirmed shipping status',
+      },
+    };
+
+    await handleTrajectoryGoalSuccess(params);
+
+    expect(matchesTrajectoryGoalSuccess).toHaveBeenCalledWith(
+      'Send the user a confirmed shipping status',
+      expect.any(String),
+      'test output',
+      undefined,
+      {},
+      params.assertion,
+      undefined,
+    );
+  });
+
+  it('passes resolved assertion vars instead of the raw test vars', async () => {
+    vi.mocked(matchesTrajectoryGoalSuccess).mockResolvedValue({
+      pass: true,
+      score: 1,
+      reason: 'Goal achieved',
+    });
+
+    const params: AssertionParams = {
+      ...defaultParams,
+      assertionValueContext: {
+        ...defaultParams.assertionValueContext,
+        vars: { orderId: 'resolved-123' },
+      },
+      test: {
+        vars: { orderId: '{{ order_id }}' },
+      },
+    };
+
+    await handleTrajectoryGoalSuccess(params);
+
+    expect(matchesTrajectoryGoalSuccess).toHaveBeenCalledWith(
+      'Resolve the order lookup task',
+      expect.any(String),
+      'test output',
+      undefined,
+      { orderId: 'resolved-123' },
+      params.assertion,
+      undefined,
+    );
+  });
+
+  it('inverts the result for not-trajectory:goal-success assertions', async () => {
+    vi.mocked(matchesTrajectoryGoalSuccess).mockResolvedValue({
+      pass: true,
+      score: 1,
+      reason: 'Goal achieved',
+    });
+
+    const params: AssertionParams = {
+      ...defaultParams,
+      inverse: true,
+      assertion: {
+        type: 'not-trajectory:goal-success',
+        value: 'Resolve the order lookup task',
+      },
+    };
+
+    const result = await handleTrajectoryGoalSuccess(params);
+
+    expect(result).toEqual({
+      pass: false,
+      score: 0,
+      reason: 'Agent unexpectedly achieved the goal: Resolve the order lookup task',
+      assertion: params.assertion,
+    });
+  });
+
+  it('preserves grader failures verbatim under inverse instead of flipping to a pass', async () => {
+    // Regression: a grader transport/parse failure must not become a passing
+    // `not-trajectory:goal-success` result. This mirrors the inverse-aware
+    // semantics already enforced by `handleLlmRubric` and `handleGEval`.
+    const graderFailure: GradingResult = {
+      pass: false,
+      score: 0,
+      reason: 'Could not extract JSON from trajectory:goal-success response',
+      metadata: { graderError: true },
+    };
+    vi.mocked(matchesTrajectoryGoalSuccess).mockResolvedValue(graderFailure);
+
+    const params: AssertionParams = {
+      ...defaultParams,
+      inverse: true,
+      assertion: {
+        type: 'not-trajectory:goal-success',
+        value: 'Resolve the order lookup task',
+      },
+    };
+
+    const result = await handleTrajectoryGoalSuccess(params);
+
+    expect(result.pass).toBe(false);
+    expect(result.score).toBe(0);
+    expect(result.metadata?.graderError).toBe(true);
+    expect(result.assertion).toBe(params.assertion);
+    expect(result.reason).toBe(graderFailure.reason);
+  });
+
+  it('throws when the assertion value does not include a goal', async () => {
+    const params: AssertionParams = {
+      ...defaultParams,
+      assertion: {
+        type: 'trajectory:goal-success',
+        value: {},
+      },
+      renderedValue: {},
+    };
+
+    await expect(handleTrajectoryGoalSuccess(params)).rejects.toThrow(
+      'trajectory:goal-success assertion must have a string value or an object with a goal property',
+    );
+  });
+});