@botpress/vai 0.0.1-beta.1

package/.env

@@ -0,0 +1,3 @@
+CLOUD_API_ENDPOINT=https://api.botpress.dev
+CLOUD_BOT_ID=151f5562-dfe8-4261-a49c-acf308807d15
+CLOUD_PAT=bp_pat_GxLLMYV5KlxFnb0ubCmQVpiMd5YwlpEG6j9A

package/README.md

@@ -0,0 +1,163 @@
+# Vitest AI
+
+**Vai** (stands for _Vitest + AI_) is a lightweight vitest extension that uses LLMs to do assertions.
+The goal of this library is primarily to allow testing the output of LLMs like the new autonomous engine, as the output is dynamic and qualitative we can't rely on traditional hard-coded tests.
+
+To remove the flakiness and human-input from these tests, we need LLMs.
+
+It's built on top of Zui and the Botpress client to interface with the different LLMs.
+
+## Usage
+
+```typescript
+import { check, rate, filter, extract } from '@botpress/vai'
+import { describe, test } from 'vitest'
+
+describe('my test suite', () => {
+  test('example', () => {
+    check('botpress', 'is a chatbot company').toBe(true)
+  })
+})
+```
+
+## `check (assertion)`
+
+Checks that the provided value matches the provided condition
+
+```typescript
+test('example', () => {
+  // works with strings
+  check('hello', 'is a greeting message').toBe(true)
+
+  // also works with objects, arrays etc..
+  check(
+    {
+      message: 'hello my friend',
+      from: 'user'
+    },
+    'is a greeting message'
+  ).toBe(true)
+})
+```
+
+## `extract (assertion)`
+
+Extracts from anything in input the requested Zui Schema:
+
+```typescript
+const person = z.object({
+  name: z.string(),
+  age: z.number().optional(),
+  country: z.string().optional()
+})
+
+extract('My name is Sylvain, I am 33 yo and live in Canada', person).toMatchObject({
+  name: 'Sylvain',
+  age: 33,
+  country: 'Canada'
+})
+```
+
+Also added support for `toMatchInlineSnapshot`:
+
+```typescript
+test('toMatchInlineSnapshot', () => {
+  extract('My name is Eric!', z.object({ name: z.string() })).toMatchInlineSnapshot(`
+    {
+      "name": "Eric",
+    }
+  `)
+})
+```
+
+## `filter (assertion)`
+
+Filters an array of anything `T[]` based on a provided condition:
+
+```typescript
+const countries = ['canada', 'germany', 'usa', 'paris', 'mexico']
+filter(countries, 'is in north america').toBe(['canada', 'usa', 'mexico'])
+filter(countries, 'is the name of a country').length.toBe(4)
+```
+
+## `rate (assertion)`
+
+Given any input `T`, gives a rating between `1` (worst) and `5` (best):
+
+```typescript
+test('good', () => rate('ghandi', 'is a good person').toBeGreaterThanOrEqual(4))
+test('evil', () => rate('hitler', 'is a good person').toBe(3))
+```
+
+## Few-shot Examples
+
+All assertion methods accept examples to provide the LLM with few-shot learning and help increase the accuracy.
+
+```typescript
+describe('learns from examples', () => {
+  test('examples are used to understand how to classify correctly', () => {
+    const examples = [
+      {
+        expected: true,
+        value: 'Rasa the chatbot framework',
+        reason: 'Rasa is a chatbot framework, so it competes with Botpress'
+      },
+      {
+        expected: false,
+        value: 'Rasa the coffee company',
+        reason: 'Since Rasa is a coffee company, it does not compete with Botpress which is not in the coffee business'
+      }
+    ]
+
+    check('Voiceflow', 'is competitor', { examples }).toBe(true)
+    check('Toyota', 'is competitor', { examples }).toBe(false)
+  })
+})
+```
+
+## Failure Messages
+
+All model predictions have nice failure messages by default:
+
+```typescript
+const countries = ['canada', 'germany', 'usa', 'paris', 'mexico']
+filter(countries, 'is in north america').toBe(['canada', 'usa'])
+```
+
+## Promises
+
+All assertion methods can also be used outside Vitest tests, as they return an `PromiseLike<T>` object that can be awaited.
+
+```typescript
+test('test truth', async () => {
+  const { result } = await check('hello', 'is a greeting message')
+  expect(result).toBe(true)
+})
+```
+
+## Bail on failure
+
+You can await the assertion to bail immediately on failure and prevent other test cases to run:
+
+```typescript
+test('no bail', () => {
+  check('hello', 'is a greeting message').toBe(false)
+  console.log('this will run as the above is not awaited, it will bail at the end of the test')
+})
+
+test('bail', async () => {
+  await check('hello', 'is a greeting message').toBe(false)
+  console.log('this will not run, the test has bailed')
+})
+```
+
+## Changing the evaluator model
+
+By default, GPT-4o mini is used to evaluate the tests, but the evaluator can be changed from inside a test:
+
+```typescript
+test('simple', () => {
+  setEvaluator('anthropic__claude-3-5-sonnet-20240620')
+  rate('hello', 'is a greeting message').toBe(5)
+})
+```

package/dist/index.cjs

@@ -0,0 +1,506 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  check: () => check,
+  compare: () => compare,
+  extract: () => extract,
+  filter: () => filter,
+  rate: () => rate,
+  setEvaluator: () => setEvaluator,
+  setupClient: () => setupClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/task/compare.ts
+var import_sdk = require("@botpress/sdk");
+var import_suite = require("vitest/suite");
+
+// src/utils/deferred.ts
+var _Deferred = class _Deferred {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+};
+__name(_Deferred, "Deferred");
+var Deferred = _Deferred;
+
+// src/task/compare.ts
+var scenarioId = import_sdk.z.string().trim().min(1, "Scenario ID/name must not be empty").max(50, "Scenario ID/name is too long");
+var ScenarioLike = import_sdk.z.union([
+  scenarioId,
+  import_sdk.z.object({ name: scenarioId }).passthrough(),
+  import_sdk.z.object({ id: scenarioId }).passthrough()
+]);
+var getScenarioName = /* @__PURE__ */ __name((scenario) => typeof scenario === "string" ? scenario : "name" in scenario ? scenario == null ? void 0 : scenario.name : scenario == null ? void 0 : scenario.id, "getScenarioName");
+var scenarioArgs = import_sdk.z.array(ScenarioLike).min(2, "You need at least two scenarios to compare").max(10, "You can only compare up to 10 scenarios").refine((scenarios) => {
+  const set = /* @__PURE__ */ new Set();
+  scenarios.forEach((scenario) => set.add(getScenarioName(scenario)));
+  return set.size === scenarios.length;
+}, "Scenarios names must be unique");
+function compare(name, scenarios, fn) {
+  scenarios = scenarioArgs.parse(scenarios);
+  return (0, import_suite.createTaskCollector)((_name, fn2, timeout) => {
+    const currentSuite = (0, import_suite.getCurrentSuite)();
+    let completedCount = 0;
+    const finished = new Deferred();
+    for (const scenario of scenarios) {
+      const key = getScenarioName(scenario);
+      currentSuite.task(key, {
+        meta: {
+          scenario: key,
+          isVaiTest: true
+        },
+        handler: /* @__PURE__ */ __name(async (context) => {
+          const extendedContext = Object.freeze({
+            scenario
+          });
+          context.onTestFinished(() => {
+            if (++completedCount === scenarios.length) {
+              finished.resolve();
+            }
+          });
+          await fn2(__spreadValues(__spreadValues({}, context), extendedContext));
+        }, "handler"),
+        timeout: timeout != null ? timeout : 1e4
+      });
+    }
+  })(name, fn);
+}
+__name(compare, "compare");
+
+// src/assertions/check.ts
+var import_sdk3 = require("@botpress/sdk");
+
+// src/context.ts
+var import_vitest = require("vitest");
+var import_suite2 = require("vitest/suite");
+var getTestMetadata = /* @__PURE__ */ __name(() => {
+  var _a;
+  const test = (0, import_suite2.getCurrentTest)();
+  return (_a = test == null ? void 0 : test.meta) != null ? _a : {
+    isVaiTest: false
+  };
+}, "getTestMetadata");
+var _client, _wrapError;
+var _VaiContext = class _VaiContext {
+  constructor() {
+    __privateAdd(this, _client, null);
+    __privateAdd(this, _wrapError, false);
+  }
+  get wrapError() {
+    return __privateGet(this, _wrapError);
+  }
+  get client() {
+    if (!__privateGet(this, _client)) {
+      throw new Error("Botpress client is not set");
+    }
+    return __privateGet(this, _client);
+  }
+  get evaluatorModel() {
+    var _a;
+    return (_a = getTestMetadata().evaluatorModel) != null ? _a : "openai__gpt-4o-mini-2024-07-18";
+  }
+  get scenario() {
+    return getTestMetadata().scenario;
+  }
+  get isVaiTest() {
+    return getTestMetadata().isVaiTest;
+  }
+  setClient(cognitive) {
+    __privateSet(this, _client, cognitive);
+  }
+  swallowErrors() {
+    if (!(0, import_suite2.getCurrentTest)()) {
+      throw new Error("cancelBail is a Vitest hook and must be called within a test");
+    }
+    __privateSet(this, _wrapError, true);
+    (0, import_vitest.onTestFinished)(() => {
+      __privateSet(this, _wrapError, false);
+    });
+  }
+};
+_client = new WeakMap();
+_wrapError = new WeakMap();
+__name(_VaiContext, "VaiContext");
+var VaiContext = _VaiContext;
+var Context = new VaiContext();
+
+// src/utils/asyncAssertion.ts
+var import_vitest2 = require("vitest");
+var import_suite3 = require("vitest/suite");
+var _AsyncExpectError = class _AsyncExpectError extends Error {
+  constructor(message, output) {
+    super(message);
+    this.output = output;
+    this.name = "AsyncExpectError";
+  }
+};
+__name(_AsyncExpectError, "AsyncExpectError");
+var AsyncExpectError = _AsyncExpectError;
+var getErrorMessages = /* @__PURE__ */ __name((e) => {
+  if (e instanceof Error) {
+    return e.message;
+  } else if (typeof e === "string") {
+    return e;
+  } else if (typeof e === "object" && e !== null) {
+    return JSON.stringify(e);
+  }
+  return `Unknown error: ${e}`;
+}, "getErrorMessages");
+var asyncExpect = /* @__PURE__ */ __name((output, assertion) => {
+  var _a, _b;
+  const promise = output.then((x) => {
+    try {
+      assertion((0, import_vitest2.expect)(x.result, x.reason));
+    } catch (e) {
+      if (Context.wrapError) {
+        return new AsyncExpectError(getErrorMessages(e), x);
+      }
+      throw e;
+    }
+    return x;
+  });
+  (_b = (_a = (0, import_suite3.getCurrentTest)()).promises) != null ? _b : _a.promises = [];
+  (0, import_suite3.getCurrentTest)().promises.push(promise);
+  return promise;
+}, "asyncExpect");
+
+// src/utils/predictJson.ts
+var import_sdk2 = require("@botpress/sdk");
+var import_json5 = __toESM(require("json5"), 1);
+var nonEmptyString = import_sdk2.z.string().trim().min(1);
+var nonEmptyObject = import_sdk2.z.object({}).passthrough().refine((value) => Object.keys(value).length > 0, {
+  message: "Expected a non-empty object"
+});
+var Input = nonEmptyString.or(nonEmptyObject).or(import_sdk2.z.array(import_sdk2.z.any()));
+var Output = import_sdk2.z.object({
+  reason: nonEmptyString.describe("A human-readable explanation of the result"),
+  result: import_sdk2.z.any().describe(
+    "Your best guess at the output according to the instructions provided, rooted in the context of the input and the reason above"
+  )
+});
+var Example = import_sdk2.z.object({
+  input: Input,
+  output: Output
+});
+var Options = import_sdk2.z.object({
+  systemMessage: import_sdk2.z.string(),
+  examples: import_sdk2.z.array(Example).default([]),
+  input: Input,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  outputSchema: import_sdk2.z.custom((value) => value instanceof import_sdk2.ZodSchema),
+  model: import_sdk2.z.string()
+});
+var isValidExample = /* @__PURE__ */ __name((outputSchema) => (example) => Input.safeParse(example.input).success && Output.safeParse(example.output).success && outputSchema.safeParse(example.output.result).success, "isValidExample");
+async function predictJson(_options) {
+  var _a, _b;
+  const options = Options.parse(_options);
+  const [integration, model] = options.model.split("__");
+  if (!(model == null ? void 0 : model.length)) {
+    throw new Error("Invalid model");
+  }
+  const exampleMessages = options.examples.filter(isValidExample(options.outputSchema)).flatMap(({ input, output: output2 }) => [
+    { role: "user", content: JSON.stringify(input, null, 2) },
+    { role: "assistant", content: JSON.stringify(output2, null, 2) }
+  ]);
+  const outputSchema = Output.extend({
+    result: options.outputSchema.describe(Output.shape.result.description)
+  });
+  const result = await Context.client.callAction({
+    type: `${integration}:generateContent`,
+    input: {
+      systemPrompt: `
+${options.systemMessage}
+
+---
+Please generate a JSON response with the following format:
+\`\`\`typescript
+${await outputSchema.toTypescriptAsync()}
+\`\`\`
+`.trim(),
+      messages: [
+        ...exampleMessages,
+        {
+          role: "user",
+          content: JSON.stringify(options.input, null, 2)
+        }
+      ],
+      temperature: 0,
+      responseFormat: "json_object",
+      model: { id: model }
+    }
+  });
+  const output = result.output;
+  if (!output.choices.length || typeof ((_b = (_a = output.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) !== "string") {
+    throw new Error("Invalid response from the model");
+  }
+  const json = output.choices[0].content.trim();
+  if (!json.length) {
+    throw new Error("No response from the model");
+  }
+  return outputSchema.parse(import_json5.default.parse(json));
+}
+__name(predictJson, "predictJson");
+
+// src/assertions/extension.ts
+var import_json52 = __toESM(require("json5"), 1);
+var import_vitest3 = require("vitest");
+var import_suite4 = require("vitest/suite");
+var toAssertion = /* @__PURE__ */ __name((promise) => {
+  return {
+    then: promise.then.bind(promise),
+    value: promise.then((value) => value.result)
+  };
+}, "toAssertion");
+var makeToMatchInlineSnapshot = /* @__PURE__ */ __name((promise) => async (expected) => {
+  const stack = new Error().stack.split("\n")[2];
+  const newStack = `
+at __INLINE_SNAPSHOT__ (node:internal/process/task_queues:1:1)
+at randomLine (node:internal/process/task_queues:1:1)
+${stack}
+`.trim();
+  const obj = import_json52.default.parse(expected != null ? expected : '""');
+  const expectation = asyncExpect(promise, (expect3) => expect3.toMatchObject(obj)).catch(() => {
+  });
+  try {
+    (0, import_vitest3.expect)((await promise).result).toMatchObject(obj);
+  } catch (err) {
+    const newError = new Error();
+    newError.stack = newStack;
+    import_vitest3.expect.getState().snapshotState.match({
+      isInline: true,
+      received: (await promise).result,
+      testName: (0, import_suite4.getCurrentTest)().name,
+      error: newError,
+      inlineSnapshot: expected
+    });
+  }
+  return expectation;
+}, "makeToMatchInlineSnapshot");
+
+// src/assertions/check.ts
+function check(value, condition, options) {
+  var _a;
+  const promise = predictJson({
+    systemMessage: `Check that the value meets the condition: ${condition}`,
+    examples: (_a = options == null ? void 0 : options.examples) == null ? void 0 : _a.map(({ value: value2, reason, expected }) => ({
+      input: value2,
+      output: { reason, result: expected }
+    })),
+    outputSchema: import_sdk3.z.boolean(),
+    model: Context.evaluatorModel,
+    input: value
+  });
+  return __spreadProps(__spreadValues({}, toAssertion(promise)), {
+    toBe: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toEqual(expected)), "toBe"),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise)
+  });
+}
+__name(check, "check");
+
+// src/assertions/extract.ts
+function extract(value, shape, options) {
+  var _a;
+  const additionalMessage = (options == null ? void 0 : options.description) ? `
+In order to extract the right information, follow these instructions:
+${options.description}
+` : "";
+  const promise = predictJson({
+    systemMessage: "From the given input, extract the required information into the requested format." + additionalMessage.trim(),
+    examples: (_a = options == null ? void 0 : options.examples) == null ? void 0 : _a.map(({ value: value2, reason, extracted }) => ({
+      input: value2,
+      output: { reason, result: extracted }
+    })),
+    outputSchema: shape,
+    model: Context.evaluatorModel,
+    input: value
+  });
+  return __spreadProps(__spreadValues({}, toAssertion(promise)), {
+    toBe: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toEqual(expected)), "toBe"),
+    toMatchObject: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toMatchObject(expected)), "toMatchObject"),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise)
+  });
+}
+__name(extract, "extract");
+
+// src/assertions/filter.ts
+var import_sdk4 = require("@botpress/sdk");
+function filter(values, condition, options) {
+  var _a, _b;
+  const mappedValues = values.map(
+    (_, idx) => import_sdk4.z.object({
+      index: (0, import_sdk4.literal)(idx),
+      reason: import_sdk4.z.string(),
+      keep: import_sdk4.z.boolean()
+    })
+  );
+  const input = values.map((value, idx) => ({
+    index: idx,
+    value
+  }));
+  const schema = import_sdk4.z.tuple(mappedValues).describe(
+    "An array of the objects with the index and a boolean value indicating if the object should be kept or not"
+  );
+  const promise = predictJson({
+    systemMessage: `
+Based on the following qualification criteria, you need to filter the given list of objects.
+Citeria: ${condition}
+
+---
+You need to return an array of objects with the index and a boolean value indicating if the object should be kept or not.
+`.trim(),
+    examples: (options == null ? void 0 : options.examples) ? [
+      {
+        input: (_a = options == null ? void 0 : options.examples) == null ? void 0 : _a.map((v, index) => ({
+          index,
+          value: v.value
+        })),
+        output: {
+          reason: "Here are some examples",
+          result: (_b = options == null ? void 0 : options.examples) == null ? void 0 : _b.map((v, idx) => ({
+            index: idx,
+            reason: v.reason,
+            keep: v.keep
+          }))
+        }
+      }
+    ] : void 0,
+    outputSchema: schema,
+    model: Context.evaluatorModel,
+    input
+  }).then((x) => {
+    const results = schema.parse(x.result);
+    return {
+      result: values.filter((_, idx) => {
+        var _a2;
+        return (_a2 = results.find((r) => r.index === idx)) == null ? void 0 : _a2.keep;
+      }),
+      reason: x.reason
+    };
+  });
+  return __spreadProps(__spreadValues({}, toAssertion(promise)), {
+    toBe: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toEqual(expected)), "toBe"),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise),
+    toHaveNoneFiltered: /* @__PURE__ */ __name(() => asyncExpect(promise, (expect3) => expect3.toEqual(values)), "toHaveNoneFiltered"),
+    toHaveSomeFiltered: /* @__PURE__ */ __name(() => asyncExpect(promise, (expect3) => expect3.not.toEqual(values)), "toHaveSomeFiltered"),
+    toBeEmpty: /* @__PURE__ */ __name(() => asyncExpect(promise, (expect3) => expect3.toHaveLength(0)), "toBeEmpty"),
+    length: {
+      toBe: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toHaveLength(expected)), "toBe"),
+      toBeGreaterThanOrEqual: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.length.greaterThanOrEqual(expected)), "toBeGreaterThanOrEqual"),
+      toBeLessThanOrEqual: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.length.lessThanOrEqual(expected)), "toBeLessThanOrEqual"),
+      toBeBetween: /* @__PURE__ */ __name((min, max) => asyncExpect(promise, (expect3) => expect3.length.within(min, max)), "toBeBetween")
+    }
+  });
+}
+__name(filter, "filter");
+
+// src/assertions/rate.ts
+var import_sdk5 = require("@botpress/sdk");
+function rate(value, condition, options) {
+  var _a;
+  const schema = import_sdk5.z.number().min(1).max(5).describe("Rating score, higher is better (1 is the worst, 5 is the best)");
+  const promise = predictJson({
+    systemMessage: `Based on the following qualification criteria, you need to rate the given situation from a score of 1 to 5.
+Scoring: 1 is the worst score, 5 is the best score possible.
+Criteria: ${condition}`,
+    examples: (_a = options == null ? void 0 : options.examples) == null ? void 0 : _a.map(({ value: value2, reason, rating }) => ({
+      input: value2,
+      output: { reason, result: rating }
+    })),
+    outputSchema: schema,
+    model: Context.evaluatorModel,
+    input: value
+  }).then((x) => {
+    return {
+      result: typeof x.result === "number" ? x.result : parseInt(x.result, 10),
+      reason: x.reason
+    };
+  });
+  return __spreadProps(__spreadValues({}, toAssertion(promise)), {
+    toBe: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toEqual(expected)), "toBe"),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise),
+    toBeGreaterThanOrEqual: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toBeGreaterThanOrEqual(expected)), "toBeGreaterThanOrEqual"),
+    toBeLessThanOrEqual: /* @__PURE__ */ __name((expected) => asyncExpect(promise, (expect3) => expect3.toBeLessThanOrEqual(expected)), "toBeLessThanOrEqual")
+  });
+}
+__name(rate, "rate");
+
+// src/hooks/setEvaluator.ts
+var import_suite5 = require("vitest/suite");
+var setEvaluator = /* @__PURE__ */ __name((model) => {
+  const test = (0, import_suite5.getCurrentTest)();
+  if (!test) {
+    throw new Error("setEvaluator is a Vitest hook and must be called within a test");
+  }
+  const meta = test.meta;
+  meta.evaluatorModel = model;
+}, "setEvaluator");
+
+// src/hooks/setupClient.ts
+var setupClient = /* @__PURE__ */ __name((client) => {
+  Context.setClient(client);
+}, "setupClient");
+//# sourceMappingURL=index.cjs.map