@botpress/zai 2.0.8 → 2.0.11

package/dist/adapters/botpress-table.js

@@ -1,4 +1,4 @@
-import { z } from "@bpinternal/zui";
+import { transforms, z } from "@bpinternal/zui";
 import { Adapter } from "./adapter";
 const CRITICAL_TAGS = {
   system: "true",
@@ -37,7 +37,7 @@ const TableSchema = z.object({
 });
 const searchableColumns = ["input"];
 const TableJsonSchema = Object.entries(TableSchema.shape).reduce((acc, [key, value]) => {
-  acc[key] = value.toJsonSchema();
+  acc[key] = transforms.toJSONSchemaLegacy(value);
   acc[key]["x-zui"] ??= {};
   acc[key]["x-zui"].searchable = searchableColumns.includes(key);
   return acc;

package/dist/index.d.ts

@@ -85,14 +85,14 @@ declare module '@botpress/zai' {
     }
 }
 
-type Example$2 = {
+type Example$3 = {
     input: string;
     output: string;
     instructions?: string;
 };
 type Options$5 = {
     /** Examples to guide the rewriting */
-    examples?: Array<Example$2>;
+    examples?: Array<Example$3>;
     /** The maximum number of tokens to generate */
     length?: number;
 };
@@ -127,13 +127,15 @@ declare module '@botpress/zai' {
     }
 }
 
+type Example$2 = {
+    input: unknown;
+    check: boolean;
+    reason?: string;
+    condition?: string;
+};
 type Options$3 = {
     /** Examples to check the condition against */
-    examples?: Array<{
-        input: unknown;
-        check: boolean;
-        reason?: string;
-    }>;
+    examples?: Array<Example$2>;
 };
 declare module '@botpress/zai' {
     interface Zai {

package/dist/operations/check.js

@@ -5,7 +5,8 @@ import { PROMPT_INPUT_BUFFER } from "./constants";
 const _Example = z.object({
   input: z.any(),
   check: z.boolean(),
-  reason: z.string().optional()
+  reason: z.string().optional(),
+  condition: z.string().optional()
 });
 const _Options = z.object({
   examples: z.array(_Example).describe("Examples to check the condition against").default([])
@@ -45,11 +46,17 @@ Zai.prototype.check = async function(input, condition, _options) {
     return { explanation: exactMatch.explanation ?? "", value: exactMatch.output };
   }
   const defaultExamples = [
-    { input: "50 Cent", check: true, reason: "50 Cent is widely recognized as a public personality." },
+    {
+      input: "50 Cent",
+      check: true,
+      reason: "50 Cent is widely recognized as a public personality.",
+      condition: "Is the input a public personality?"
+    },
     {
       input: ["apple", "banana", "carrot", "house"],
       check: false,
-      reason: "The list contains a house, which is not a fruit. Also, the list contains a carrot, which is a vegetable."
+      reason: "The list contains a house, which is not a fruit. Also, the list contains a carrot, which is a vegetable.",
+      condition: "Is the input exclusively a list of fruits?"
     }
   ];
   const userExamples = [
@@ -74,7 +81,11 @@ ${END}
 `.trim();
   };
   const formatExample = (example) => [
-    { type: "text", content: formatInput(stringify(example.input ?? null), condition), role: "user" },
+    {
+      type: "text",
+      content: formatInput(stringify(example.input ?? null), example.condition ?? condition),
+      role: "user"
+    },
     {
       type: "text",
       content: formatOutput(example.check, example.reason ?? ""),

package/dist/operations/extract.js

@@ -39,7 +39,7 @@ Zai.prototype.extract = async function(input, _schema, _options) {
   } else {
     throw new Error("Schema must be either a ZuiObject or a ZuiArray<ZuiObject>");
   }
-  const schemaTypescript = schema.toTypescript({ declaration: false });
+  const schemaTypescript = schema.toTypescriptType({ declaration: false });
   const schemaLength = tokenizer.count(schemaTypescript);
   options.chunkLength = Math.min(
     options.chunkLength,

package/e2e/client.ts

@@ -0,0 +1,151 @@
+import { Client } from '@botpress/client'
+import { Cognitive } from '@botpress/cognitive'
+import { diffLines } from 'diff'
+import fs from 'node:fs'
+import path from 'node:path'
+import { expect } from 'vitest'
+
+function stringifyWithSortedKeys(obj: any, space?: number): string {
+  function sortKeys(input: any): any {
+    if (Array.isArray(input)) {
+      return input.map(sortKeys)
+    } else if (input && typeof input === 'object' && input.constructor === Object) {
+      return Object.keys(input)
+        .sort()
+        .reduce(
+          (acc, key) => {
+            acc[key] = sortKeys(input[key])
+            return acc
+          },
+          {} as Record<string, any>
+        )
+    } else {
+      return input
+    }
+  }
+
+  return JSON.stringify(sortKeys(obj), null, space)
+}
+
+function readJSONL<T>(filePath: string, keyProperty: keyof T): Map<string, T> {
+  const lines = fs.readFileSync(filePath, 'utf-8').split(/\r?\n/).filter(Boolean)
+
+  const map = new Map<string, T>()
+
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line) as T
+      const key = String(obj[keyProperty])
+      map.set(key, obj)
+    } catch {}
+  }
+
+  return map
+}
+
+type CacheEntry = { key: string; value: any; test: string; input: string }
+
+const cache: Map<string, CacheEntry> = readJSONL(path.resolve(__dirname, './data/cache.jsonl'), 'key')
+const cacheByTest: Map<string, CacheEntry> = readJSONL(path.resolve(__dirname, './data/cache.jsonl'), 'test')
+
+class CachedClient extends Client {
+  #client: Client
+  #callsByTest: Record<string, number> = {}
+
+  public constructor(options: ConstructorParameters<typeof Client>[0]) {
+    super(options)
+    this.#client = new Client(options)
+  }
+
+  public callAction = async (...args: Parameters<Client['callAction']>) => {
+    const currentTestName = expect.getState().currentTestName ?? 'default'
+    this.#callsByTest[currentTestName] ||= 0
+    this.#callsByTest[currentTestName]++
+
+    const testKey = `${currentTestName}-${this.#callsByTest[currentTestName]}`
+
+    const key = fastHash(stringifyWithSortedKeys(args))
+    const cached = cache.get(key)
+
+    if (cached) {
+      return cached.value
+    }
+
+    if (process.env.CI && cacheByTest.has(testKey)) {
+      console.info(`Cache miss for ${key} in test ${testKey}`)
+      console.info(
+        diffLines(
+          JSON.stringify(JSON.parse(cacheByTest.get(testKey)?.input!), null, 2),
+          JSON.stringify(JSON.parse(stringifyWithSortedKeys(args)), null, 2)
+        )
+      )
+    }
+
+    const response = await this.#client.callAction(...args)
+    cache.set(key, { key, value: response, test: testKey, input: stringifyWithSortedKeys(args) })
+
+    fs.appendFileSync(
+      path.resolve(__dirname, './data/cache.jsonl'),
+      JSON.stringify({
+        test: testKey,
+        key,
+        input: stringifyWithSortedKeys(args),
+        value: response,
+      }) + '\n'
+    )
+
+    return response
+  }
+
+  public clone() {
+    return this
+  }
+}
+
+export const getCachedCognitiveClient = () => {
+  const cognitive = new Cognitive({
+    client: new CachedClient({
+      apiUrl: process.env.CLOUD_API_ENDPOINT ?? 'https://api.botpress.dev',
+      botId: process.env.CLOUD_BOT_ID,
+      token: process.env.CLOUD_PAT,
+    }),
+    provider: {
+      deleteModelPreferences: async () => {},
+      saveModelPreferences: async () => {},
+      fetchInstalledModels: async () => [
+        {
+          ref: 'openai:gpt-4o-2024-11-20',
+          integration: 'openai',
+          id: 'gpt-4o-2024-11-20',
+          name: 'GPT-4o (November 2024)',
+          description:
+            "GPT-4o (“o” for “omni”) is OpenAI's most advanced model. It is multimodal (accepting text or image inputs and outputting text), and it has the same high intelligence as GPT-4 Turbo but is cheaper and more efficient.",
+          input: {
+            costPer1MTokens: 2.5,
+            maxTokens: 128000,
+          },
+          output: {
+            costPer1MTokens: 10,
+            maxTokens: 16384,
+          },
+          tags: ['recommended', 'vision', 'general-purpose', 'coding', 'agents', 'function-calling'],
+        },
+      ],
+      fetchModelPreferences: async () => ({
+        best: ['openai:gpt-4o-2024-11-20'] as const,
+        fast: ['openai:gpt-4o-2024-11-20'] as const,
+        downtimes: [],
+      }),
+    },
+  })
+  return cognitive
+}
+
+function fastHash(str: string): string {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i)
+    hash |= 0 // Convert to 32bit integer
+  }
+  return (hash >>> 0).toString(16) // Convert to unsigned and then to hex
+}