@botpress/vai 0.0.1-beta.7 → 0.0.2-beta.1

package/dist/assertions/check.js

@@ -0,0 +1,23 @@
+"use strict";
+import { z } from "@bpinternal/zui";
+import { Context } from "../context";
+import { asyncExpect } from "../utils/asyncAssertion";
+import { predictJson } from "../utils/predictJson";
+import { makeToMatchInlineSnapshot, toAssertion } from "./extension";
+export function check(value, condition, options) {
+  const promise = predictJson({
+    systemMessage: `Check that the value meets the condition: ${condition}`,
+    examples: options?.examples?.map(({ value: value2, reason, expected }) => ({
+      input: value2,
+      output: { reason, result: expected }
+    })),
+    outputSchema: z.boolean(),
+    model: Context.evaluatorModel,
+    input: value
+  });
+  return {
+    ...toAssertion(promise),
+    toBe: (expected) => asyncExpect(promise, (expect) => expect.toEqual(expected)),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise)
+  };
+}

package/dist/assertions/extension.js

@@ -0,0 +1,36 @@
+"use strict";
+import json5 from "json5";
+import { expect } from "vitest";
+import { getCurrentTest } from "vitest/suite";
+import { asyncExpect } from "../utils/asyncAssertion";
+export const toAssertion = (promise) => {
+  return {
+    then: promise.then.bind(promise),
+    value: promise.then((value) => value.result)
+  };
+};
+export const makeToMatchInlineSnapshot = (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 = json5.parse(expected ?? '""');
+  const expectation = asyncExpect(promise, (expect2) => expect2.toMatchObject(obj)).catch(() => {
+  });
+  try {
+    expect((await promise).result).toMatchObject(obj);
+  } catch (err) {
+    const newError = new Error();
+    newError.stack = newStack;
+    expect.getState().snapshotState.match({
+      isInline: true,
+      received: (await promise).result,
+      testName: getCurrentTest().name,
+      error: newError,
+      inlineSnapshot: expected
+    });
+  }
+  return expectation;
+};

package/dist/assertions/extract.js

@@ -0,0 +1,27 @@
+"use strict";
+import { Context } from "../context";
+import { asyncExpect } from "../utils/asyncAssertion";
+import { predictJson } from "../utils/predictJson";
+import { makeToMatchInlineSnapshot, toAssertion } from "./extension";
+export function extract(value, shape, options) {
+  const additionalMessage = 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: options?.examples?.map(({ value: value2, reason, extracted }) => ({
+      input: value2,
+      output: { reason, result: extracted }
+    })),
+    outputSchema: shape,
+    model: Context.evaluatorModel,
+    input: value
+  });
+  return {
+    ...toAssertion(promise),
+    toBe: (expected) => asyncExpect(promise, (expect) => expect.toEqual(expected)),
+    toMatchObject: (expected) => asyncExpect(promise, (expect) => expect.toMatchObject(expected)),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise)
+  };
+}

package/dist/assertions/filter.js

@@ -0,0 +1,70 @@
+"use strict";
+import { z } from "@bpinternal/zui";
+import { Context } from "../context";
+import { asyncExpect } from "../utils/asyncAssertion";
+import { predictJson } from "../utils/predictJson";
+import { makeToMatchInlineSnapshot, toAssertion } from "./extension";
+export function filter(values, condition, options) {
+  const mappedValues = values.map(
+    (_, idx) => z.object({
+      index: z.literal(idx),
+      reason: z.string(),
+      keep: z.boolean()
+    })
+  );
+  const input = values.map((value, idx) => ({
+    index: idx,
+    value
+  }));
+  const schema = 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?.examples ? [
+      {
+        input: options?.examples?.map((v, index) => ({
+          index,
+          value: v.value
+        })),
+        output: {
+          reason: "Here are some examples",
+          result: options?.examples?.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) => results.find((r) => r.index === idx)?.keep),
+      reason: x.reason
+    };
+  });
+  return {
+    ...toAssertion(promise),
+    toBe: (expected) => asyncExpect(promise, (expect) => expect.toEqual(expected)),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise),
+    toHaveNoneFiltered: () => asyncExpect(promise, (expect) => expect.toEqual(values)),
+    toHaveSomeFiltered: () => asyncExpect(promise, (expect) => expect.not.toEqual(values)),
+    toBeEmpty: () => asyncExpect(promise, (expect) => expect.toHaveLength(0)),
+    length: {
+      toBe: (expected) => asyncExpect(promise, (expect) => expect.toHaveLength(expected)),
+      toBeGreaterThanOrEqual: (expected) => asyncExpect(promise, (expect) => expect.length.greaterThanOrEqual(expected)),
+      toBeLessThanOrEqual: (expected) => asyncExpect(promise, (expect) => expect.length.lessThanOrEqual(expected)),
+      toBeBetween: (min, max) => asyncExpect(promise, (expect) => expect.length.within(min, max))
+    }
+  };
+}

package/dist/assertions/rate.js

@@ -0,0 +1,33 @@
+"use strict";
+import { z } from "@bpinternal/zui";
+import { Context } from "../context";
+import { asyncExpect } from "../utils/asyncAssertion";
+import { predictJson } from "../utils/predictJson";
+import { makeToMatchInlineSnapshot, toAssertion } from "./extension";
+export function rate(value, condition, options) {
+  const schema = 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: options?.examples?.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 {
+    ...toAssertion(promise),
+    toBe: (expected) => asyncExpect(promise, (expect) => expect.toEqual(expected)),
+    toMatchInlineSnapshot: makeToMatchInlineSnapshot(promise),
+    toBeGreaterThanOrEqual: (expected) => asyncExpect(promise, (expect) => expect.toBeGreaterThanOrEqual(expected)),
+    toBeLessThanOrEqual: (expected) => asyncExpect(promise, (expect) => expect.toBeLessThanOrEqual(expected))
+  };
+}

package/dist/context.js

@@ -0,0 +1,44 @@
+"use strict";
+import { onTestFinished } from "vitest";
+import { getCurrentTest } from "vitest/suite";
+const getTestMetadata = () => {
+  const test = getCurrentTest();
+  return test?.meta ?? {
+    isVaiTest: false
+  };
+};
+class VaiContext {
+  #client = null;
+  #wrapError = false;
+  get wrapError() {
+    return this.#wrapError;
+  }
+  get client() {
+    if (!this.#client) {
+      throw new Error("Botpress client is not set");
+    }
+    return this.#client;
+  }
+  get evaluatorModel() {
+    return getTestMetadata().evaluatorModel ?? "openai__gpt-4o-mini-2024-07-18";
+  }
+  get scenario() {
+    return getTestMetadata().scenario;
+  }
+  get isVaiTest() {
+    return getTestMetadata().isVaiTest;
+  }
+  setClient(cognitive) {
+    this.#client = cognitive;
+  }
+  swallowErrors() {
+    if (!getCurrentTest()) {
+      throw new Error("cancelBail is a Vitest hook and must be called within a test");
+    }
+    this.#wrapError = true;
+    onTestFinished(() => {
+      this.#wrapError = false;
+    });
+  }
+}
+export const Context = new VaiContext();

package/dist/hooks/setEvaluator.js

@@ -0,0 +1,10 @@
+"use strict";
+import { getCurrentTest } from "vitest/suite";
+export const setEvaluator = (model) => {
+  const test = 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;
+};

package/dist/hooks/setupClient.js

@@ -0,0 +1,5 @@
+"use strict";
+import { Context } from "../context";
+export const setupClient = (client) => {
+  Context.setClient(client);
+};

package/dist/index.d.ts

@@ -1,35 +1,35 @@
-import * as _botpress_sdk from '@botpress/sdk';
-import { z } from '@botpress/sdk';
+import * as _bpinternal_zui from '@bpinternal/zui';
+import { z, AnyZodObject } from '@bpinternal/zui';
 import { TestFunction } from 'vitest';
 import { Client } from '@botpress/client';
 
 type ScenarioLike = z.infer<typeof ScenarioLike>;
-declare const ScenarioLike: _botpress_sdk.ZodUnion<[_botpress_sdk.ZodString, _botpress_sdk.ZodObject<{
-    name: _botpress_sdk.ZodString;
-}, "passthrough", _botpress_sdk.ZodTypeAny, _botpress_sdk.objectOutputType<{
-    name: _botpress_sdk.ZodString;
-}, _botpress_sdk.ZodTypeAny, "passthrough">, _botpress_sdk.objectInputType<{
-    name: _botpress_sdk.ZodString;
-}, _botpress_sdk.ZodTypeAny, "passthrough">>, _botpress_sdk.ZodObject<{
-    id: _botpress_sdk.ZodString;
-}, "passthrough", _botpress_sdk.ZodTypeAny, _botpress_sdk.objectOutputType<{
-    id: _botpress_sdk.ZodString;
-}, _botpress_sdk.ZodTypeAny, "passthrough">, _botpress_sdk.objectInputType<{
-    id: _botpress_sdk.ZodString;
-}, _botpress_sdk.ZodTypeAny, "passthrough">>]>;
+declare const ScenarioLike: _bpinternal_zui.ZodUnion<[_bpinternal_zui.ZodString, _bpinternal_zui.ZodObject<{
+    name: _bpinternal_zui.ZodString;
+}, "passthrough", _bpinternal_zui.ZodTypeAny, _bpinternal_zui.objectOutputType<{
+    name: _bpinternal_zui.ZodString;
+}, _bpinternal_zui.ZodTypeAny, "passthrough">, _bpinternal_zui.objectInputType<{
+    name: _bpinternal_zui.ZodString;
+}, _bpinternal_zui.ZodTypeAny, "passthrough">>, _bpinternal_zui.ZodObject<{
+    id: _bpinternal_zui.ZodString;
+}, "passthrough", _bpinternal_zui.ZodTypeAny, _bpinternal_zui.objectOutputType<{
+    id: _bpinternal_zui.ZodString;
+}, _bpinternal_zui.ZodTypeAny, "passthrough">, _bpinternal_zui.objectInputType<{
+    id: _bpinternal_zui.ZodString;
+}, _bpinternal_zui.ZodTypeAny, "passthrough">>]>;
 declare function compare<T extends ReadonlyArray<ScenarioLike>>(name: string | Function, scenarios: T, fn?: TestFunction<{
     scenario: T[number];
 }>): void;
 
 type Input = z.infer<typeof Input>;
-declare const Input: _botpress_sdk.ZodUnion<[_botpress_sdk.ZodUnion<[_botpress_sdk.ZodString, z.ZodTransformer<_botpress_sdk.ZodObject<{}, "passthrough", _botpress_sdk.ZodTypeAny, _botpress_sdk.objectOutputType<{}, _botpress_sdk.ZodTypeAny, "passthrough">, _botpress_sdk.objectInputType<{}, _botpress_sdk.ZodTypeAny, "passthrough">>, _botpress_sdk.objectOutputType<{}, _botpress_sdk.ZodTypeAny, "passthrough">, _botpress_sdk.objectInputType<{}, _botpress_sdk.ZodTypeAny, "passthrough">>]>, _botpress_sdk.ZodArray<_botpress_sdk.ZodAny, "many">]>;
+declare const Input: _bpinternal_zui.ZodUnion<[_bpinternal_zui.ZodUnion<[_bpinternal_zui.ZodString, z.ZodTransformer<_bpinternal_zui.ZodObject<{}, "passthrough", _bpinternal_zui.ZodTypeAny, _bpinternal_zui.objectOutputType<{}, _bpinternal_zui.ZodTypeAny, "passthrough">, _bpinternal_zui.objectInputType<{}, _bpinternal_zui.ZodTypeAny, "passthrough">>, _bpinternal_zui.objectOutputType<{}, _bpinternal_zui.ZodTypeAny, "passthrough">, _bpinternal_zui.objectInputType<{}, _bpinternal_zui.ZodTypeAny, "passthrough">>]>, _bpinternal_zui.ZodArray<_bpinternal_zui.ZodAny, "many">]>;
 type Output<T = any> = z.infer<typeof Output> & {
     result: T;
 };
-declare const Output: _botpress_sdk.ZodObject<{
-    reason: _botpress_sdk.ZodString;
-    result: _botpress_sdk.ZodAny;
-}, "strip", _botpress_sdk.ZodTypeAny, {
+declare const Output: _bpinternal_zui.ZodObject<{
+    reason: _bpinternal_zui.ZodString;
+    result: _bpinternal_zui.ZodAny;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     reason: string;
     result?: any;
 }, {
@@ -64,7 +64,7 @@ type ExtractOptions<T, S> = {
         reason: string;
     }[];
 };
-declare function extract<T extends Input, S extends z.AnyZodObject>(value: T, shape: S, options?: ExtractOptions<T, z.infer<S>>): {
+declare function extract<T extends Input, S extends AnyZodObject>(value: T, shape: S, options?: ExtractOptions<T, z.infer<S>>): {
     toBe: (expected: z.infer<S>) => Promise<Output<z.infer<S>> | AsyncExpectError<z.infer<S>>>;
     toMatchObject: (expected: Partial<z.infer<S>>) => Promise<Output<z.infer<S>> | AsyncExpectError<z.infer<S>>>;
     toMatchInlineSnapshot: (expected?: string) => Promise<void | Output<z.infer<S>> | AsyncExpectError<z.infer<S>>>;