@botpress/zai 1.0.0-beta.8 → 1.0.1-beta.1

package/dist/csj/zai.js

@@ -0,0 +1,142 @@
+import sdk from "@botpress/sdk";
+import { getWasmTokenizer } from "@botpress/wasm";
+import { TableAdapter } from "./adapters/botpress-table";
+import { MemoryAdapter } from "./adapters/memory";
+import { Models } from "./models";
+import { BotpressClient } from "./utils";
+const { z } = sdk;
+const ActiveLearning = z.object({
+  enable: z.boolean().describe("Whether to enable active learning").default(false),
+  tableName: z.string().regex(
+    /^[A-Za-z0-9_/-]{1,100}Table$/,
+    "Namespace must be alphanumeric and contain only letters, numbers, underscores, hyphens and slashes"
+  ).describe("The name of the table to store active learning tasks").default("ActiveLearningTable"),
+  taskId: z.string().regex(
+    /^[A-Za-z0-9_/-]{1,100}$/,
+    "Namespace must be alphanumeric and contain only letters, numbers, underscores, hyphens and slashes"
+  ).describe("The ID of the task").default("default")
+});
+const ZaiConfig = z.object({
+  client: BotpressClient,
+  userId: z.string().describe("The ID of the user consuming the API").optional(),
+  retry: z.object({ maxRetries: z.number().min(0).max(100) }).default({ maxRetries: 3 }),
+  modelId: z.custom(
+    (value) => {
+      if (typeof value !== "string" || !value.includes("__")) {
+        return false;
+      }
+      return true;
+    },
+    {
+      message: "Invalid model ID"
+    }
+  ).describe("The ID of the model you want to use").default("openai__gpt-4o-mini-2024-07-18"),
+  activeLearning: ActiveLearning.default({ enable: false }),
+  namespace: z.string().regex(
+    /^[A-Za-z0-9_/-]{1,100}$/,
+    "Namespace must be alphanumeric and contain only letters, numbers, underscores, hyphens and slashes"
+  ).default("zai")
+});
+export class Zai {
+  static tokenizer = null;
+  client;
+  originalConfig;
+  userId;
+  integration;
+  model;
+  retry;
+  Model;
+  namespace;
+  adapter;
+  activeLearning;
+  constructor(config) {
+    var _a;
+    this.originalConfig = config;
+    const parsed = ZaiConfig.parse(config);
+    this.client = parsed.client;
+    const [integration, modelId] = parsed.modelId.split("__");
+    if (!(integration == null ? void 0 : integration.length) || !(modelId == null ? void 0 : modelId.length)) {
+      throw new Error(`Invalid model ID: ${parsed.modelId}. Expected format: <integration>__<modelId>`);
+    }
+    this.integration = integration;
+    this.model = modelId;
+    this.namespace = parsed.namespace;
+    this.userId = parsed.userId;
+    this.retry = parsed.retry;
+    this.Model = Models.find((m) => m.id === parsed.modelId);
+    this.activeLearning = parsed.activeLearning;
+    this.adapter = ((_a = parsed.activeLearning) == null ? void 0 : _a.enable) ? new TableAdapter({ client: this.client, tableName: parsed.activeLearning.tableName }) : new MemoryAdapter([]);
+  }
+  /** @internal */
+  async callModel(props) {
+    let retries = this.retry.maxRetries;
+    while (retries-- >= 0) {
+      try {
+        return await this._callModel(props);
+      } catch (e) {
+        if (retries >= 0) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        } else {
+          throw new Error("Failed to call model after multiple retries");
+        }
+      }
+    }
+    throw new Error("Failed to call model after multiple retries");
+  }
+  /** @internal */
+  async _callModel(props) {
+    let retries = this.retry.maxRetries;
+    do {
+      const start = Date.now();
+      const input = {
+        messages: [],
+        temperature: 0,
+        topP: 1,
+        model: { id: this.model },
+        userId: this.userId,
+        ...props
+      };
+      const { output } = await this.client.callAction({
+        type: `${this.integration}:generateContent`,
+        input
+      });
+      const latency = Date.now() - start;
+      return {
+        ...output,
+        metadata: {
+          model: this.model,
+          latency,
+          cost: { input: output.usage.inputCost, output: output.usage.outputCost },
+          tokens: { input: output.usage.inputTokens, output: output.usage.outputTokens }
+        }
+      };
+    } while (--retries > 0);
+  }
+  async getTokenizer() {
+    Zai.tokenizer ??= await (async () => {
+      while (!getWasmTokenizer) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+      return getWasmTokenizer();
+    })();
+    return Zai.tokenizer;
+  }
+  get taskId() {
+    if (!this.activeLearning.enable) {
+      return void 0;
+    }
+    return `${this.namespace}/${this.activeLearning.taskId}`.replace(/\/+/g, "/");
+  }
+  with(options) {
+    return new Zai({
+      ...this.originalConfig,
+      ...options
+    });
+  }
+  learn(taskId) {
+    return new Zai({
+      ...this.originalConfig,
+      activeLearning: { ...this.activeLearning, taskId, enable: true }
+    });
+  }
+}

package/dist/esm/adapters/adapter.js

@@ -0,0 +1,5 @@
+class Adapter {
+}
+export {
+  Adapter
+};

package/dist/esm/adapters/botpress-table.js

@@ -0,0 +1,194 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import sdk from "@botpress/sdk";
+const { z } = sdk;
+import { BotpressClient, 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: BotpressClient,
+  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]) => {
+  var _a, _b;
+  acc[key] = value.toJsonSchema();
+  (_b = (_a = acc[key])["x-zui"]) != null ? _b : _a["x-zui"] = {};
+  acc[key]["x-zui"].searchable = searchableColumns.includes(key);
+  return acc;
+}, {});
+class TableAdapter extends Adapter {
+  constructor(props) {
+    super();
+    __publicField(this, "client");
+    __publicField(this, "tableName");
+    __publicField(this, "status");
+    __publicField(this, "errors", []);
+    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) => {
+      var _a;
+      return {
+        key: row.key,
+        input: row.input.value,
+        output: row.output.value,
+        explanation: row.explanation,
+        similarity: (_a = row.similarity) != null ? _a : 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 ? explanation : null,
+          status,
+          metadata
+        }
+      ]
+    }).catch(() => {
+    });
+  }
+  async assertTableExists() {
+    var _a, _b, _c;
+    if (this.status !== "ready") {
+      return;
+    }
+    const { table, created } = await this.client.getOrCreateTable({
+      table: this.tableName,
+      factor: FACTOR,
+      frozen: true,
+      isComputeEnabled: false,
+      tags: __spreadValues(__spreadValues({}, CRITICAL_TAGS), OPTIONAL_TAGS),
+      schema: TableJsonSchema
+    }).catch((err) => {
+      this.status = "error";
+      this.errors = [err.message];
+      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 (((_a = table.tags) == null ? void 0 : _a[key]) !== value) {
+          issues.push(`Tag ${key} is ${(_b = table.tags) == null ? void 0 : _b[key]} instead of ${value}`);
+        }
+      }
+      for (const key of Object.keys(TableJsonSchema)) {
+        const column = (_c = table.schema) == null ? void 0 : _c.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.errors = issues;
+      }
+    }
+    this.status = "initialized";
+  }
+}
+export {
+  TableAdapter
+};

package/dist/esm/adapters/memory.js

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

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import { Zai } from "./zai";
+import "./operations/text";
+import "./operations/rewrite";
+import "./operations/summarize";
+import "./operations/check";
+import "./operations/filter";
+import "./operations/extract";
+import "./operations/label";
+export {
+  Zai
+};