@botpress/zai 1.0.1 → 1.2.0

package/README.md

@@ -10,7 +10,7 @@ It's built on top of Zui and the Botpress client to interface with the different
 import Zai from '@botpress/zai'
 
 const zai = new Zai({
-  client: new Client({}) // your botpress client here
+  client: new Client({}), // your botpress client here
 })
 ```
 

package/build.ts

@@ -0,0 +1,9 @@
+import esbuild from 'esbuild'
+import glob from 'glob'
+
+const entryPoints = glob.sync('./src/**/*.ts')
+void esbuild.build({
+  entryPoints,
+  platform: 'neutral',
+  outdir: './dist',
+})

package/dist/adapters/adapter.js

@@ -0,0 +1,2 @@
+export class Adapter {
+}

package/dist/adapters/botpress-table.js

@@ -0,0 +1,168 @@
+import { z } from "@bpinternal/zui";
+import { GenerationMetadata } from "../utils";
+import { Adapter } from "./adapter";
+const CRITICAL_TAGS = {
+  system: "true",
+  "schema-purpose": "active-learning",
+  "schema-version": "Oct-2024"
+};
+const OPTIONAL_TAGS = {
+  "x-studio-title": "Active Learning",
+  "x-studio-description": "Table for storing active learning tasks and examples",
+  "x-studio-readonly": "true",
+  "x-studio-icon": "lucide://atom",
+  "x-studio-color": "green"
+};
+const FACTOR = 30;
+const Props = z.object({
+  client: z.custom(() => true),
+  tableName: z.string().regex(
+    /^[a-zA-Z0-9_]{1,45}Table$/,
+    "Table name must be lowercase and contain only letters, numbers and underscores"
+  )
+});
+const TableSchema = z.object({
+  taskType: z.string().describe("The type of the task (filter, extract, etc.)"),
+  taskId: z.string(),
+  key: z.string().describe("A unique key for the task (e.g. a hash of the input, taskId, taskType and instructions)"),
+  instructions: z.string(),
+  input: z.object({}).passthrough().describe("The input to the task"),
+  output: z.object({}).passthrough().describe("The expected output"),
+  explanation: z.string().nullable(),
+  metadata: GenerationMetadata,
+  status: z.enum(["pending", "rejected", "approved"]),
+  feedback: z.object({
+    rating: z.enum(["very-bad", "bad", "good", "very-good"]),
+    comment: z.string().nullable()
+  }).nullable().default(null)
+});
+const searchableColumns = ["input"];
+const TableJsonSchema = Object.entries(TableSchema.shape).reduce((acc, [key, value]) => {
+  acc[key] = value.toJsonSchema();
+  acc[key]["x-zui"] ??= {};
+  acc[key]["x-zui"].searchable = searchableColumns.includes(key);
+  return acc;
+}, {});
+export class TableAdapter extends Adapter {
+  _client;
+  _tableName;
+  _status;
+  constructor(props) {
+    super();
+    props = Props.parse(props);
+    this._client = props.client;
+    this._tableName = props.tableName;
+    this._status = "ready";
+  }
+  async getExamples({ taskType, taskId, input }) {
+    await this._assertTableExists();
+    const { rows } = await this._client.findTableRows({
+      table: this._tableName,
+      search: JSON.stringify({ value: input }).substring(0, 1023),
+      // Search is limited to 1024 characters
+      limit: 10,
+      // TODO
+      filter: {
+        // Proximity match of approved examples
+        taskType,
+        taskId,
+        status: "approved"
+      }
+    }).catch((err) => {
+      console.error(`Error fetching examples: ${err.message}`);
+      return { rows: [] };
+    });
+    return rows.map((row) => ({
+      key: row.key,
+      input: row.input.value,
+      output: row.output.value,
+      explanation: row.explanation,
+      similarity: row.similarity ?? 0
+    }));
+  }
+  async saveExample({
+    key,
+    taskType,
+    taskId,
+    instructions,
+    input,
+    output,
+    explanation,
+    metadata,
+    status = "pending"
+  }) {
+    await this._assertTableExists();
+    await this._client.upsertTableRows({
+      table: this._tableName,
+      keyColumn: "key",
+      rows: [
+        {
+          key,
+          taskType,
+          taskId,
+          instructions,
+          input: { value: input },
+          output: { value: output },
+          explanation: explanation ?? null,
+          status,
+          metadata
+        }
+      ]
+    }).catch(() => {
+    });
+  }
+  async _assertTableExists() {
+    if (this._status !== "ready") {
+      return;
+    }
+    const { table, created } = await this._client.getOrCreateTable({
+      table: this._tableName,
+      factor: FACTOR,
+      frozen: true,
+      isComputeEnabled: false,
+      tags: {
+        ...CRITICAL_TAGS,
+        ...OPTIONAL_TAGS
+      },
+      schema: TableJsonSchema
+    }).catch(() => {
+      this._status = "error";
+      return { table: null, created: false };
+    });
+    if (!table) {
+      return;
+    }
+    if (!created) {
+      const issues = [];
+      if (table.factor !== FACTOR) {
+        issues.push(`Factor is ${table.factor} instead of ${FACTOR}`);
+      }
+      if (table.frozen !== true) {
+        issues.push("Table is not frozen");
+      }
+      for (const [key, value] of Object.entries(CRITICAL_TAGS)) {
+        if (table.tags?.[key] !== value) {
+          issues.push(`Tag ${key} is ${table.tags?.[key]} instead of ${value}`);
+        }
+      }
+      for (const key of Object.keys(TableJsonSchema)) {
+        const column = table.schema?.properties[key];
+        const expected = TableJsonSchema[key];
+        if (!column) {
+          issues.push(`Column ${key} is missing`);
+          continue;
+        }
+        if (column.type !== expected.type) {
+          issues.push(`Column ${key} has type ${column.type} instead of ${expected.type}`);
+        }
+        if (expected["x-zui"].searchable && !column["x-zui"].searchable) {
+          issues.push(`Column ${key} is not searchable but should be`);
+        }
+      }
+      if (issues.length) {
+        this._status = "error";
+      }
+    }
+    this._status = "initialized";
+  }
+}

package/dist/adapters/memory.js

@@ -0,0 +1,12 @@
+import { Adapter } from "./adapter";
+export class MemoryAdapter extends Adapter {
+  constructor(examples) {
+    super();
+    this.examples = examples;
+  }
+  async getExamples() {
+    return this.examples;
+  }
+  async saveExample() {
+  }
+}