@botpress/zai 1.0.1-beta.4 → 1.0.1-beta.5

package/dist/index.js

@@ -0,0 +1,1743 @@
+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 __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 __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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Zai: () => Zai
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/zai.ts
+var import_zui3 = require("@bpinternal/zui");
+var import_wasm = require("@botpress/wasm");
+
+// src/adapters/botpress-table.ts
+var import_zui2 = require("@bpinternal/zui");
+
+// src/utils.ts
+var import_zui = require("@bpinternal/zui");
+var stringify = (input, beautify = true) => {
+  return typeof input === "string" && !!input.length ? input : input ? JSON.stringify(input, beautify ? null : void 0, beautify ? 2 : void 0) : "<input is null, false, undefined or empty>";
+};
+var BotpressClient = import_zui.z.custom(
+  (value) => typeof value === "object" && value !== null && "callAction" in value && typeof value.callAction === "function",
+  {
+    message: "Invalid Botpress Client. Make sure to pass an instance of @botpress/client"
+  }
+);
+function fastHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(16);
+}
+var takeUntilTokens = (arr, tokens, count) => {
+  const result = [];
+  let total = 0;
+  for (const value of arr) {
+    const valueTokens = count(value);
+    if (total + valueTokens > tokens) {
+      break;
+    }
+    total += valueTokens;
+    result.push(value);
+  }
+  return result;
+};
+var GenerationMetadata = import_zui.z.object({
+  model: import_zui.z.string(),
+  cost: import_zui.z.object({
+    input: import_zui.z.number(),
+    output: import_zui.z.number()
+  }).describe("Cost in $USD"),
+  latency: import_zui.z.number().describe("Latency in milliseconds"),
+  tokens: import_zui.z.object({
+    input: import_zui.z.number(),
+    output: import_zui.z.number()
+  }).describe("Number of tokens used")
+});
+
+// src/adapters/adapter.ts
+var Adapter = class {
+};
+
+// src/adapters/botpress-table.ts
+var CRITICAL_TAGS = {
+  system: "true",
+  "schema-purpose": "active-learning",
+  "schema-version": "Oct-2024"
+};
+var 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"
+};
+var FACTOR = 30;
+var Props = import_zui2.z.object({
+  client: BotpressClient,
+  tableName: import_zui2.z.string().regex(
+    /^[a-zA-Z0-9_]{1,45}Table$/,
+    "Table name must be lowercase and contain only letters, numbers and underscores"
+  )
+});
+var TableSchema = import_zui2.z.object({
+  taskType: import_zui2.z.string().describe("The type of the task (filter, extract, etc.)"),
+  taskId: import_zui2.z.string(),
+  key: import_zui2.z.string().describe("A unique key for the task (e.g. a hash of the input, taskId, taskType and instructions)"),
+  instructions: import_zui2.z.string(),
+  input: import_zui2.z.object({}).passthrough().describe("The input to the task"),
+  output: import_zui2.z.object({}).passthrough().describe("The expected output"),
+  explanation: import_zui2.z.string().nullable(),
+  metadata: GenerationMetadata,
+  status: import_zui2.z.enum(["pending", "rejected", "approved"]),
+  feedback: import_zui2.z.object({
+    rating: import_zui2.z.enum(["very-bad", "bad", "good", "very-good"]),
+    comment: import_zui2.z.string().nullable()
+  }).nullable().default(null)
+});
+var searchableColumns = ["input"];
+var 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;
+}, {});
+var TableAdapter = class extends Adapter {
+  constructor(props) {
+    super();
+    __publicField(this, "client");
+    __publicField(this, "tableName");
+    __publicField(this, "status");
+    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: ".concat(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(() => {
+      this.status = "error";
+      return { table: null, created: false };
+    });
+    if (!table) {
+      return;
+    }
+    if (!created) {
+      const issues = [];
+      if (table.factor !== FACTOR) {
+        issues.push("Factor is ".concat(table.factor, " instead of ").concat(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 ".concat(key, " is ").concat((_b = table.tags) == null ? void 0 : _b[key], " instead of ").concat(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 ".concat(key, " is missing"));
+          continue;
+        }
+        if (column.type !== expected.type) {
+          issues.push("Column ".concat(key, " has type ").concat(column.type, " instead of ").concat(expected.type));
+        }
+        if (expected["x-zui"].searchable && !column["x-zui"].searchable) {
+          issues.push("Column ".concat(key, " is not searchable but should be"));
+        }
+      }
+      if (issues.length) {
+        this.status = "error";
+      }
+    }
+    this.status = "initialized";
+  }
+};
+
+// src/adapters/memory.ts
+var MemoryAdapter = class extends Adapter {
+  constructor(examples) {
+    super();
+    this.examples = examples;
+  }
+  async getExamples() {
+    return this.examples;
+  }
+  async saveExample() {
+  }
+};
+
+// src/models.ts
+var Models = [
+  {
+    "id": "anthropic__claude-3-haiku-20240307",
+    "name": "Claude 3 Haiku",
+    "integration": "anthropic",
+    "input": {
+      "maxTokens": 2e5
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "anthropic__claude-3-5-sonnet-20240620",
+    "name": "Claude 3.5 Sonnet",
+    "integration": "anthropic",
+    "input": {
+      "maxTokens": 2e5
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "cerebras__llama3.1-70b",
+    "name": "Llama 3.1 70B",
+    "integration": "cerebras",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "cerebras__llama3.1-8b",
+    "name": "Llama 3.1 8B",
+    "integration": "cerebras",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/deepseek-coder-v2-instruct",
+    "name": "DeepSeek Coder V2 Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 131072
+    },
+    "output": {
+      "maxTokens": 131072
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/deepseek-coder-v2-lite-instruct",
+    "name": "DeepSeek Coder V2 Lite",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 163840
+    },
+    "output": {
+      "maxTokens": 163840
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/firellava-13b",
+    "name": "FireLLaVA-13B",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 4096
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/firefunction-v2",
+    "name": "Firefunction V2",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/gemma2-9b-it",
+    "name": "Gemma 2 9B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/llama-v3p1-405b-instruct",
+    "name": "Llama 3.1 405B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 131072
+    },
+    "output": {
+      "maxTokens": 131072
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/llama-v3p1-70b-instruct",
+    "name": "Llama 3.1 70B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 131072
+    },
+    "output": {
+      "maxTokens": 131072
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/llama-v3p1-8b-instruct",
+    "name": "Llama 3.1 8B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 131072
+    },
+    "output": {
+      "maxTokens": 131072
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/mixtral-8x22b-instruct",
+    "name": "Mixtral MoE 8x22B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 65536
+    },
+    "output": {
+      "maxTokens": 65536
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/mixtral-8x7b-instruct",
+    "name": "Mixtral MoE 8x7B Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 32768
+    },
+    "output": {
+      "maxTokens": 32768
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/mythomax-l2-13b",
+    "name": "MythoMax L2 13b",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 4096
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "fireworks-ai__accounts/fireworks/models/qwen2-72b-instruct",
+    "name": "Qwen2 72b Instruct",
+    "integration": "fireworks-ai",
+    "input": {
+      "maxTokens": 32768
+    },
+    "output": {
+      "maxTokens": 32768
+    }
+  },
+  {
+    "id": "groq__gemma2-9b-it",
+    "name": "Gemma2 9B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama3-70b-8192",
+    "name": "LLaMA 3 70B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama3-8b-8192",
+    "name": "LLaMA 3 8B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 8192
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.1-70b-versatile",
+    "name": "LLaMA 3.1 70B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.1-8b-instant",
+    "name": "LLaMA 3.1 8B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.2-11b-vision-preview",
+    "name": "LLaMA 3.2 11B Vision",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.2-1b-preview",
+    "name": "LLaMA 3.2 1B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.2-3b-preview",
+    "name": "LLaMA 3.2 3B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.2-90b-vision-preview",
+    "name": "LLaMA 3.2 90B Vision",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 8192
+    }
+  },
+  {
+    "id": "groq__llama-3.3-70b-versatile",
+    "name": "LLaMA 3.3 70B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 32768
+    }
+  },
+  {
+    "id": "groq__mixtral-8x7b-32768",
+    "name": "Mixtral 8x7B",
+    "integration": "groq",
+    "input": {
+      "maxTokens": 32768
+    },
+    "output": {
+      "maxTokens": 32768
+    }
+  },
+  {
+    "id": "openai__o1-2024-12-17",
+    "name": "GPT o1",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 2e5
+    },
+    "output": {
+      "maxTokens": 1e5
+    }
+  },
+  {
+    "id": "openai__o1-mini-2024-09-12",
+    "name": "GPT o1-mini",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 65536
+    }
+  },
+  {
+    "id": "openai__gpt-3.5-turbo-0125",
+    "name": "GPT-3.5 Turbo",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "openai__gpt-4-turbo-2024-04-09",
+    "name": "GPT-4 Turbo",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "openai__gpt-4o-2024-08-06",
+    "name": "GPT-4o (August 2024)",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 16384
+    }
+  },
+  {
+    "id": "openai__gpt-4o-2024-05-13",
+    "name": "GPT-4o (May 2024)",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 4096
+    }
+  },
+  {
+    "id": "openai__gpt-4o-2024-11-20",
+    "name": "GPT-4o (November 2024)",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 16384
+    }
+  },
+  {
+    "id": "openai__gpt-4o-mini-2024-07-18",
+    "name": "GPT-4o Mini",
+    "integration": "openai",
+    "input": {
+      "maxTokens": 128e3
+    },
+    "output": {
+      "maxTokens": 16384
+    }
+  }
+];
+
+// src/zai.ts
+var ActiveLearning = import_zui3.z.object({
+  enable: import_zui3.z.boolean().describe("Whether to enable active learning").default(false),
+  tableName: import_zui3.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: import_zui3.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")
+});
+var ZaiConfig = import_zui3.z.object({
+  client: BotpressClient,
+  userId: import_zui3.z.string().describe("The ID of the user consuming the API").optional(),
+  retry: import_zui3.z.object({ maxRetries: import_zui3.z.number().min(0).max(100) }).default({ maxRetries: 3 }),
+  modelId: import_zui3.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: import_zui3.z.string().regex(
+    /^[A-Za-z0-9_/-]{1,100}$/,
+    "Namespace must be alphanumeric and contain only letters, numbers, underscores, hyphens and slashes"
+  ).default("zai")
+});
+var _Zai = class _Zai {
+  constructor(config) {
+    __publicField(this, "client");
+    __publicField(this, "originalConfig");
+    __publicField(this, "userId");
+    __publicField(this, "integration");
+    __publicField(this, "model");
+    __publicField(this, "retry");
+    __publicField(this, "Model");
+    __publicField(this, "namespace");
+    __publicField(this, "adapter");
+    __publicField(this, "activeLearning");
+    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: ".concat(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 = __spreadValues({
+        messages: [],
+        temperature: 0,
+        topP: 1,
+        model: { id: this.model },
+        userId: this.userId
+      }, props);
+      const { output } = await this.client.callAction({
+        type: "".concat(this.integration, ":generateContent"),
+        input
+      });
+      const latency = Date.now() - start;
+      return __spreadProps(__spreadValues({}, 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() {
+    var _a;
+    (_a = _Zai.tokenizer) != null ? _a : _Zai.tokenizer = await (async () => {
+      while (!import_wasm.getWasmTokenizer) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+      return (0, import_wasm.getWasmTokenizer)();
+    })();
+    return _Zai.tokenizer;
+  }
+  get taskId() {
+    if (!this.activeLearning.enable) {
+      return void 0;
+    }
+    return "".concat(this.namespace, "/").concat(this.activeLearning.taskId).replace(/\/+/g, "/");
+  }
+  with(options) {
+    return new _Zai(__spreadValues(__spreadValues({}, this.originalConfig), options));
+  }
+  learn(taskId) {
+    return new _Zai(__spreadProps(__spreadValues({}, this.originalConfig), {
+      activeLearning: __spreadProps(__spreadValues({}, this.activeLearning), { taskId, enable: true })
+    }));
+  }
+};
+__publicField(_Zai, "tokenizer", null);
+var Zai = _Zai;
+
+// src/operations/text.ts
+var import_zui4 = require("@bpinternal/zui");
+var import_lodash_es = require("lodash-es");
+
+// src/operations/constants.ts
+var PROMPT_INPUT_BUFFER = 1048;
+var PROMPT_OUTPUT_BUFFER = 512;
+
+// src/operations/text.ts
+var Options = import_zui4.z.object({
+  length: import_zui4.z.number().min(1).max(1e5).optional().describe("The maximum number of tokens to generate")
+});
+Zai.prototype.text = async function(prompt, _options) {
+  var _a, _b;
+  const options = Options.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  prompt = tokenizer.truncate(prompt, Math.max(this.Model.input.maxTokens - PROMPT_INPUT_BUFFER, 100));
+  if (options.length) {
+    options.length = Math.min(this.Model.output.maxTokens - PROMPT_OUTPUT_BUFFER, options.length);
+  }
+  const instructions = [];
+  let chart = "";
+  if (options.length) {
+    const length = (0, import_lodash_es.clamp)(options.length * 0.75, 5, options.length);
+    instructions.push("IMPORTANT: Length constraint: ".concat(length, " tokens/words"));
+    instructions.push("The text must be standalone and complete in less than ".concat(length, " tokens/words"));
+  }
+  if (options.length && options.length <= 500) {
+    chart = "\n| Tokens      | Text Length (approximate)            |\n|-------------|--------------------------------------|\n| < 5 tokens  | 1-3 words                            |\n| 5-10 tokens | 3-6 words                            |\n| 10-20 tokens| 6-15 words                           |\n| 20-50 tokens| A short sentence (15-30 words)       |\n| 50-100 tokens| A medium sentence (30-70 words)     |\n| 100-200 tokens| A short paragraph (70-150 words)   |\n| 200-300 tokens| A medium paragraph (150-200 words) |\n| 300-500 tokens| A long paragraph (200-300 words)   |".trim();
+  }
+  const output = await this.callModel({
+    systemPrompt: "\nGenerate a text that fulfills the user prompt below. Answer directly to the prompt, without any acknowledgements or fluff. Also, make sure the text is standalone and complete.\n".concat(instructions.map((x) => "- ".concat(x)).join("\n"), "\n").concat(chart, "\n").trim(),
+    temperature: 0.7,
+    messages: [{ type: "text", content: prompt, role: "user" }],
+    maxTokens: options.length
+  });
+  return (_b = (_a = output == null ? void 0 : output.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.content;
+};
+
+// src/operations/rewrite.ts
+var import_zui5 = require("@bpinternal/zui");
+var Example = import_zui5.z.object({
+  input: import_zui5.z.string(),
+  output: import_zui5.z.string()
+});
+var Options2 = import_zui5.z.object({
+  examples: import_zui5.z.array(Example).default([]),
+  length: import_zui5.z.number().min(10).max(16e3).optional().describe("The maximum number of tokens to generate")
+});
+var START = "\u25A0START\u25A0";
+var END = "\u25A0END\u25A0";
+Zai.prototype.rewrite = async function(original, prompt, _options) {
+  var _a;
+  const options = Options2.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  const taskId = this.taskId;
+  const taskType = "zai.rewrite";
+  const INPUT_COMPONENT_SIZE = Math.max(100, (this.Model.input.maxTokens - PROMPT_INPUT_BUFFER) / 2);
+  prompt = tokenizer.truncate(prompt, INPUT_COMPONENT_SIZE);
+  const inputSize = tokenizer.count(original) + tokenizer.count(prompt);
+  const maxInputSize = this.Model.input.maxTokens - tokenizer.count(prompt) - PROMPT_INPUT_BUFFER;
+  if (inputSize > maxInputSize) {
+    throw new Error(
+      "The input size is ".concat(inputSize, " tokens long, which is more than the maximum of ").concat(maxInputSize, " tokens for this model (").concat(this.Model.name, " = ").concat(this.Model.input.maxTokens, " tokens)")
+    );
+  }
+  const instructions = [];
+  const originalSize = tokenizer.count(original);
+  if (options.length && originalSize > options.length) {
+    instructions.push("The original text is ".concat(originalSize, " tokens long \u2013 it should be less than ").concat(options.length));
+    instructions.push(
+      "The text must be standalone and complete in less than ".concat(options.length, " tokens, so it has to be shortened to fit the length as well")
+    );
+  }
+  const format = (before, prompt2) => {
+    return "\nPrompt: ".concat(prompt2, "\n\n").concat(START, "\n").concat(before, "\n").concat(END, "\n").trim();
+  };
+  const Key = fastHash(
+    stringify({
+      taskId,
+      taskType,
+      input: original,
+      prompt
+    })
+  );
+  const formatExample = ({ input, output: output2, instructions: instructions2 }) => {
+    return [
+      { type: "text", role: "user", content: format(input, instructions2 || prompt) },
+      { type: "text", role: "assistant", content: "".concat(START).concat(output2).concat(END) }
+    ];
+  };
+  const defaultExamples = [
+    { input: "Hello, how are you?", output: "Bonjour, comment \xE7a va?", instructions: "translate to French" },
+    { input: "1\n2\n3", output: "3\n2\n1", instructions: "reverse the order" }
+  ];
+  const tableExamples = taskId ? await this.adapter.getExamples({
+    input: original,
+    taskId,
+    taskType
+  }) : [];
+  const exactMatch = tableExamples.find((x) => x.key === Key);
+  if (exactMatch) {
+    return exactMatch.output;
+  }
+  const savedExamples = [
+    ...tableExamples.map((x) => ({ input: x.input, output: x.output })),
+    ...options.examples
+  ];
+  const REMAINING_TOKENS = this.Model.input.maxTokens - tokenizer.count(prompt) - PROMPT_INPUT_BUFFER;
+  const examples = takeUntilTokens(
+    savedExamples.length ? savedExamples : defaultExamples,
+    REMAINING_TOKENS,
+    (el) => tokenizer.count(stringify(el.input)) + tokenizer.count(stringify(el.output))
+  ).map(formatExample).flat();
+  const output = await this.callModel({
+    systemPrompt: "\nRewrite the text between the ".concat(START, " and ").concat(END, " tags to match the user prompt.\n").concat(instructions.map((x) => "\u2022 ".concat(x)).join("\n"), "\n").trim(),
+    messages: [...examples, { type: "text", content: format(original, prompt), role: "user" }],
+    maxTokens: options.length,
+    stopSequences: [END]
+  });
+  let result = (_a = output.choices[0]) == null ? void 0 : _a.content;
+  if (result.includes(START)) {
+    result = result.slice(result.indexOf(START) + START.length);
+  }
+  if (result.includes(END)) {
+    result = result.slice(0, result.indexOf(END));
+  }
+  if (taskId) {
+    await this.adapter.saveExample({
+      key: Key,
+      metadata: output.metadata,
+      instructions: prompt,
+      input: original,
+      output: result,
+      taskType,
+      taskId
+    });
+  }
+  return result;
+};
+
+// src/operations/summarize.ts
+var import_zui6 = require("@bpinternal/zui");
+var import_lodash_es2 = require("lodash-es");
+var Options3 = import_zui6.z.object({
+  prompt: import_zui6.z.string().describe("What should the text be summarized to?").default("New information, concepts and ideas that are deemed important"),
+  format: import_zui6.z.string().describe("How to format the example text").default(
+    "A normal text with multiple sentences and paragraphs. Use markdown to format the text into sections. Use headings, lists, and other markdown features to make the text more readable. Do not include links, images, or other non-text elements."
+  ),
+  length: import_zui6.z.number().min(10).max(1e5).describe("The length of the summary in tokens").default(250),
+  intermediateFactor: import_zui6.z.number().min(1).max(10).describe("How many times longer (than final length) are the intermediate summaries generated").default(4),
+  maxIterations: import_zui6.z.number().min(1).default(100),
+  sliding: import_zui6.z.object({
+    window: import_zui6.z.number().min(10).max(1e5),
+    overlap: import_zui6.z.number().min(0).max(1e5)
+  }).describe("Sliding window options").default({ window: 5e4, overlap: 250 })
+});
+var START2 = "\u25A0START\u25A0";
+var END2 = "\u25A0END\u25A0";
+Zai.prototype.summarize = async function(original, _options) {
+  var _a;
+  const options = Options3.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  const INPUT_COMPONENT_SIZE = Math.max(100, (this.Model.input.maxTokens - PROMPT_INPUT_BUFFER) / 4);
+  options.prompt = tokenizer.truncate(options.prompt, INPUT_COMPONENT_SIZE);
+  options.format = tokenizer.truncate(options.format, INPUT_COMPONENT_SIZE);
+  const maxOutputSize = this.Model.output.maxTokens - PROMPT_OUTPUT_BUFFER;
+  if (options.length > maxOutputSize) {
+    throw new Error(
+      "The desired output length is ".concat(maxOutputSize, " tokens long, which is more than the maximum of ").concat(this.Model.output.maxTokens, " tokens for this model (").concat(this.Model.name, ")")
+    );
+  }
+  options.sliding.window = Math.min(options.sliding.window, this.Model.input.maxTokens - PROMPT_INPUT_BUFFER);
+  options.sliding.overlap = Math.min(options.sliding.overlap, options.sliding.window - 3 * options.sliding.overlap);
+  const format = (summary, newText) => {
+    return "\n".concat(START2, "\n").concat(summary.length ? summary : "<summary still empty>", "\n").concat(END2, "\n\nPlease amend the summary between the ").concat(START2, " and ").concat(END2, " tags to accurately reflect the prompt and the additional text below.\n\n<|start_new_information|>\n").concat(newText, "\n<|new_information|>").trim();
+  };
+  const tokens = tokenizer.split(original);
+  const parts = Math.ceil(tokens.length / (options.sliding.window - options.sliding.overlap));
+  let iteration = 0;
+  const N = 2;
+  const useMergeSort = parts >= Math.pow(2, N);
+  const chunkSize = Math.ceil(tokens.length / (parts * N));
+  if (useMergeSort) {
+    const chunks = (0, import_lodash_es2.chunk)(tokens, chunkSize).map((x) => x.join(""));
+    const allSummaries = await Promise.all(chunks.map((chunk4) => this.summarize(chunk4, options)));
+    return this.summarize(allSummaries.join("\n\n============\n\n"), options);
+  }
+  const summaries = [];
+  let currentSummary = "";
+  for (let i = 0; i < tokens.length; i += options.sliding.window) {
+    const from = Math.max(0, i - options.sliding.overlap);
+    const to = Math.min(tokens.length, i + options.sliding.window + options.sliding.overlap);
+    const isFirst = i === 0;
+    const isLast = to >= tokens.length;
+    const slice = tokens.slice(from, to).join("");
+    if (iteration++ >= options.maxIterations) {
+      break;
+    }
+    const instructions = [
+      "At each step, you will receive a part of the text to summarize. Make sure to reply with the new summary in the tags ".concat(START2, " and ").concat(END2, "."),
+      "Summarize the text and make sure that the main points are included.",
+      "Ignore any unnecessary details and focus on the main points.",
+      "Use short and concise sentences to increase readability and information density.",
+      "When looking at the new information, focus on: " + options.prompt
+    ];
+    if (isFirst) {
+      instructions.push(
+        "The current summary is empty. You need to generate a summary that covers the main points of the text."
+      );
+    }
+    let generationLength = options.length;
+    if (!isLast) {
+      generationLength = Math.min(
+        tokenizer.count(currentSummary) + options.length * options.intermediateFactor,
+        maxOutputSize
+      );
+      instructions.push(
+        "You need to amend the summary to include the new information. Make sure the summary is complete and covers all the main points."
+      );
+      instructions.push("The current summary is ".concat(currentSummary.length, " tokens long."));
+      instructions.push("You can amend the summary to be up to ".concat(generationLength, " tokens long."));
+    }
+    if (isLast) {
+      instructions.push(
+        "This is the last part you will have to summarize. Make sure the summary is complete and covers all the main points."
+      );
+      instructions.push(
+        "The current summary is ".concat(currentSummary.length, " tokens long. You need to make sure it is ").concat(options.length, " tokens or less.")
+      );
+      if (currentSummary.length > options.length) {
+        instructions.push(
+          "The current summary is already too long, so you need to shorten it to ".concat(options.length, " tokens while also including the new information.")
+        );
+      }
+    }
+    const output = await this.callModel({
+      systemPrompt: "\nYou are summarizing a text. The text is split into ".concat(parts, " parts, and you are currently working on part ").concat(iteration, ".\nAt every step, you will receive the current summary and a new part of the text. You need to amend the summary to include the new information (if needed).\nThe summary needs to cover the main points of the text and must be concise.\n\nIMPORTANT INSTRUCTIONS:\n").concat(instructions.map((x) => "- ".concat(x.trim())).join("\n"), "\n\nFORMAT OF THE SUMMARY:\n").concat(options.format, "\n").trim(),
+      messages: [{ type: "text", content: format(currentSummary, slice), role: "user" }],
+      maxTokens: generationLength,
+      stopSequences: [END2]
+    });
+    let result = (_a = output == null ? void 0 : output.choices[0]) == null ? void 0 : _a.content;
+    if (result.includes(START2)) {
+      result = result.slice(result.indexOf(START2) + START2.length);
+    }
+    if (result.includes("\u25A0")) {
+      result = result.slice(0, result.indexOf("\u25A0"));
+    }
+    summaries.push(result);
+    currentSummary = result;
+  }
+  return currentSummary.trim();
+};
+
+// src/operations/check.ts
+var import_zui7 = require("@bpinternal/zui");
+var Example2 = import_zui7.z.object({
+  input: import_zui7.z.any(),
+  check: import_zui7.z.boolean(),
+  reason: import_zui7.z.string().optional()
+});
+var Options4 = import_zui7.z.object({
+  examples: import_zui7.z.array(Example2).describe("Examples to check the condition against").default([])
+});
+var TRUE = "\u25A0TRUE\u25A0";
+var FALSE = "\u25A0FALSE\u25A0";
+var END3 = "\u25A0END\u25A0";
+Zai.prototype.check = async function(input, condition, _options) {
+  var _a;
+  const options = Options4.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  const PROMPT_COMPONENT = Math.max(this.Model.input.maxTokens - PROMPT_INPUT_BUFFER, 100);
+  const taskId = this.taskId;
+  const taskType = "zai.check";
+  const PROMPT_TOKENS = {
+    INPUT: Math.floor(0.5 * PROMPT_COMPONENT),
+    CONDITION: Math.floor(0.2 * PROMPT_COMPONENT)
+  };
+  const inputAsString = tokenizer.truncate(stringify(input), PROMPT_TOKENS.INPUT);
+  condition = tokenizer.truncate(condition, PROMPT_TOKENS.CONDITION);
+  const EXAMPLES_TOKENS = PROMPT_COMPONENT - tokenizer.count(inputAsString) - tokenizer.count(condition);
+  const Key = fastHash(
+    JSON.stringify({
+      taskType,
+      taskId,
+      input: inputAsString,
+      condition
+    })
+  );
+  const examples = taskId ? await this.adapter.getExamples({
+    input: inputAsString,
+    taskType,
+    taskId
+  }) : [];
+  const exactMatch = examples.find((x) => x.key === Key);
+  if (exactMatch) {
+    return exactMatch.output;
+  }
+  const defaultExamples = [
+    { input: "50 Cent", check: true, reason: "50 Cent is widely recognized as 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."
+    }
+  ];
+  const userExamples = [
+    ...examples.map((e) => ({ input: e.input, check: e.output, reason: e.explanation })),
+    ...options.examples
+  ];
+  let exampleId = 1;
+  const formatInput = (input2, condition2) => {
+    const header = userExamples.length ? "Expert Example #".concat(exampleId++) : 'Example of condition: "'.concat(condition2, '"');
+    return "\n".concat(header, "\n<|start_input|>\n").concat(input2.trim(), "\n<|end_input|>\n").trim();
+  };
+  const formatOutput = (answer2, justification) => {
+    return "\nAnalysis: ".concat(justification, "\nFinal Answer: ").concat(answer2 ? TRUE : FALSE, "\n").concat(END3, "\n").trim();
+  };
+  const formatExample = (example) => {
+    var _a2, _b;
+    return [
+      { type: "text", content: formatInput(stringify((_a2 = example.input) != null ? _a2 : null), condition), role: "user" },
+      {
+        type: "text",
+        content: formatOutput(example.check, (_b = example.reason) != null ? _b : ""),
+        role: "assistant"
+      }
+    ];
+  };
+  const allExamples = takeUntilTokens(
+    userExamples.length ? userExamples : defaultExamples,
+    EXAMPLES_TOKENS,
+    (el) => {
+      var _a2;
+      return tokenizer.count(stringify(el.input)) + tokenizer.count((_a2 = el.reason) != null ? _a2 : "");
+    }
+  ).map(formatExample).flat();
+  const specialInstructions = userExamples.length ? "\n- You have been provided with examples from previous experts. Make sure to read them carefully before making your decision.\n- Make sure to refer to the examples provided by the experts to justify your decision (when applicable).\n- When in doubt, ground your decision on the examples provided by the experts instead of your own intuition.\n- When no example is similar to the input, make sure to provide a clear justification for your decision while inferring the decision-making process from the examples provided by the experts.\n".trim() : "";
+  const output = await this.callModel({
+    systemPrompt: "\nCheck if the following condition is true or false for the given input. Before answering, make sure to read the input and the condition carefully.\nJustify your answer, then answer with either ".concat(TRUE, " or ").concat(FALSE, " at the very end, then add ").concat(END3, " to finish the response.\nIMPORTANT: Make sure to answer with either ").concat(TRUE, " or ").concat(FALSE, " at the end of your response, but NOT both.\n---\nExpert Examples (#1 to #").concat(exampleId - 1, "):\n").concat(specialInstructions, "\n").trim(),
+    stopSequences: [END3],
+    messages: [
+      ...allExamples,
+      {
+        type: "text",
+        content: "\nConsidering the below input and above examples, is the following condition true or false?\n".concat(formatInput(inputAsString, condition), '\nIn your "Analysis", please refer to the Expert Examples # to justify your decision.').trim(),
+        role: "user"
+      }
+    ]
+  });
+  const answer = (_a = output.choices[0]) == null ? void 0 : _a.content;
+  const hasTrue = answer.includes(TRUE);
+  const hasFalse = answer.includes(FALSE);
+  if (!hasTrue && !hasFalse) {
+    throw new Error("The model did not return a valid answer. The response was: ".concat(answer));
+  }
+  let finalAnswer;
+  if (hasTrue && hasFalse) {
+    finalAnswer = answer.lastIndexOf(TRUE) > answer.lastIndexOf(FALSE);
+  } else {
+    finalAnswer = hasTrue;
+  }
+  if (taskId) {
+    await this.adapter.saveExample({
+      key: Key,
+      taskType,
+      taskId,
+      input: inputAsString,
+      instructions: condition,
+      metadata: output.metadata,
+      output: finalAnswer,
+      explanation: answer.replace(TRUE, "").replace(FALSE, "").replace(END3, "").replace("Final Answer:", "").trim()
+    });
+  }
+  return finalAnswer;
+};
+
+// src/operations/filter.ts
+var import_zui8 = require("@bpinternal/zui");
+var import_lodash_es3 = require("lodash-es");
+var Example3 = import_zui8.z.object({
+  input: import_zui8.z.any(),
+  filter: import_zui8.z.boolean(),
+  reason: import_zui8.z.string().optional()
+});
+var Options5 = import_zui8.z.object({
+  tokensPerItem: import_zui8.z.number().min(1).max(1e5).optional().describe("The maximum number of tokens per item").default(250),
+  examples: import_zui8.z.array(Example3).describe("Examples to filter the condition against").default([])
+});
+var END4 = "\u25A0END\u25A0";
+Zai.prototype.filter = async function(input, condition, _options) {
+  const options = Options5.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  const taskId = this.taskId;
+  const taskType = "zai.filter";
+  const MAX_ITEMS_PER_CHUNK = 50;
+  const TOKENS_TOTAL_MAX = this.Model.input.maxTokens - PROMPT_INPUT_BUFFER - PROMPT_OUTPUT_BUFFER;
+  const TOKENS_EXAMPLES_MAX = Math.floor(Math.max(250, TOKENS_TOTAL_MAX * 0.5));
+  const TOKENS_CONDITION_MAX = (0, import_lodash_es3.clamp)(TOKENS_TOTAL_MAX * 0.25, 250, tokenizer.count(condition));
+  const TOKENS_INPUT_ARRAY_MAX = TOKENS_TOTAL_MAX - TOKENS_EXAMPLES_MAX - TOKENS_CONDITION_MAX;
+  condition = tokenizer.truncate(condition, TOKENS_CONDITION_MAX);
+  let chunks = [];
+  let currentChunk = [];
+  let currentChunkTokens = 0;
+  for (const element of input) {
+    const elementAsString = tokenizer.truncate(stringify(element, false), options.tokensPerItem);
+    const elementTokens = tokenizer.count(elementAsString);
+    if (currentChunkTokens + elementTokens > TOKENS_INPUT_ARRAY_MAX || currentChunk.length >= MAX_ITEMS_PER_CHUNK) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentChunkTokens = 0;
+    }
+    currentChunk.push(element);
+    currentChunkTokens += elementTokens;
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  chunks = chunks.filter((x) => x.length > 0);
+  const formatInput = (input2, condition2) => {
+    return "\nCondition to check:\n".concat(condition2, "\n\nItems (from \u25A00 to \u25A0").concat(input2.length - 1, ")\n==============================\n").concat(input2.map((x, idx) => {
+      var _a;
+      return "\u25A0".concat(idx, " = ").concat(stringify((_a = x.input) != null ? _a : null, false));
+    }).join("\n"), "\n").trim();
+  };
+  const formatExamples = (examples) => {
+    return "\n".concat(examples.map((x, idx) => "\u25A0".concat(idx, ":").concat(!!x.filter ? "true" : "false")).join(""), "\n").concat(END4, "\n====\nHere's the reasoning behind each example:\n").concat(examples.map((x, idx) => {
+      var _a;
+      return "\u25A0".concat(idx, ":").concat(!!x.filter ? "true" : "false", ":").concat((_a = x.reason) != null ? _a : "No reason provided");
+    }).join("\n"), "\n").trim();
+  };
+  const genericExamples = [
+    {
+      input: "apple",
+      filter: true,
+      reason: "Apples are fruits"
+    },
+    {
+      input: "Apple Inc.",
+      filter: false,
+      reason: "Apple Inc. is a company, not a fruit"
+    },
+    {
+      input: "banana",
+      filter: true,
+      reason: "Bananas are fruits"
+    },
+    {
+      input: "potato",
+      filter: false,
+      reason: "Potatoes are vegetables"
+    }
+  ];
+  const genericExamplesMessages = [
+    {
+      type: "text",
+      content: formatInput(genericExamples, "is a fruit"),
+      role: "user"
+    },
+    {
+      type: "text",
+      content: formatExamples(genericExamples),
+      role: "assistant"
+    }
+  ];
+  const filterChunk = async (chunk4) => {
+    var _a, _b;
+    const examples = taskId ? await this.adapter.getExamples({
+      // The Table API can't search for a huge input string
+      input: JSON.stringify(chunk4).slice(0, 1e3),
+      taskType,
+      taskId
+    }).then(
+      (x) => x.map((y) => ({ filter: y.output, input: y.input, reason: y.explanation }))
+    ) : [];
+    const allExamples = takeUntilTokens(
+      [...examples, ...(_a = options.examples) != null ? _a : []],
+      TOKENS_EXAMPLES_MAX,
+      (el) => tokenizer.count(stringify(el.input))
+    );
+    const exampleMessages = [
+      {
+        type: "text",
+        content: formatInput(allExamples, condition),
+        role: "user"
+      },
+      {
+        type: "text",
+        content: formatExamples(allExamples),
+        role: "assistant"
+      }
+    ];
+    const output = await this.callModel({
+      systemPrompt: '\nYou are given a list of items. Your task is to filter out the items that meet the condition below.\nYou need to return the full list of items with the format:\n\u25A0x:true\u25A0y:false\u25A0z:true (where x, y, z are the indices of the items in the list)\nYou need to start with "\u25A00" and go up to the last index "\u25A0'.concat(chunk4.length - 1, '".\nIf an item meets the condition, you should return ":true", otherwise ":false".\n\nIMPORTANT: Make sure to read the condition and the examples carefully before making your decision.\nThe condition is: "').concat(condition, '"\n').trim(),
+      stopSequences: [END4],
+      messages: [
+        ...exampleMessages.length ? exampleMessages : genericExamplesMessages,
+        {
+          type: "text",
+          content: formatInput(
+            chunk4.map((x) => ({ input: x })),
+            condition
+          ),
+          role: "user"
+        }
+      ]
+    });
+    const answer = (_b = output.choices[0]) == null ? void 0 : _b.content;
+    const indices = answer.trim().split("\u25A0").filter((x) => x.length > 0).map((x) => {
+      var _a2;
+      const [idx, filter] = x.split(":");
+      return { idx: parseInt((_a2 = idx == null ? void 0 : idx.trim()) != null ? _a2 : ""), filter: (filter == null ? void 0 : filter.toLowerCase().trim()) === "true" };
+    });
+    const partial = chunk4.filter((_, idx) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = indices.find((x) => x.idx === idx)) == null ? void 0 : _a2.filter) != null ? _b2 : false;
+    });
+    if (taskId) {
+      const key = fastHash(
+        stringify({
+          taskId,
+          taskType,
+          input: JSON.stringify(chunk4),
+          condition
+        })
+      );
+      await this.adapter.saveExample({
+        key,
+        taskType,
+        taskId,
+        input: JSON.stringify(chunk4),
+        output: partial,
+        instructions: condition,
+        metadata: output.metadata
+      });
+    }
+    return partial;
+  };
+  const filteredChunks = await Promise.all(chunks.map(filterChunk));
+  return filteredChunks.flat();
+};
+
+// src/operations/extract.ts
+var import_zui9 = require("@bpinternal/zui");
+var import_json5 = __toESM(require("json5"));
+var import_jsonrepair = require("jsonrepair");
+var import_lodash_es4 = require("lodash-es");
+
+// src/operations/errors.ts
+var JsonParsingError = class extends Error {
+  constructor(json, error) {
+    const message = "Error parsing JSON:\n\n---JSON---\n".concat(json, "\n\n---Error---\n\n ").concat(error);
+    super(message);
+    this.json = json;
+    this.error = error;
+  }
+};
+
+// src/operations/extract.ts
+var Options6 = import_zui9.z.object({
+  instructions: import_zui9.z.string().optional().describe("Instructions to guide the user on how to extract the data"),
+  chunkLength: import_zui9.z.number().min(100).max(1e5).optional().describe("The maximum number of tokens per chunk").default(16e3)
+});
+var START3 = "\u25A0json_start\u25A0";
+var END5 = "\u25A0json_end\u25A0";
+var NO_MORE = "\u25A0NO_MORE_ELEMENT\u25A0";
+Zai.prototype.extract = async function(input, schema, _options) {
+  var _a, _b, _c;
+  const options = Options6.parse(_options != null ? _options : {});
+  const tokenizer = await this.getTokenizer();
+  const taskId = this.taskId;
+  const taskType = "zai.extract";
+  const PROMPT_COMPONENT = Math.max(this.Model.input.maxTokens - PROMPT_INPUT_BUFFER, 100);
+  let isArrayOfObjects = false;
+  const originalSchema = schema;
+  if (schema instanceof import_zui9.z.ZodObject) {
+  } else if (schema instanceof import_zui9.z.ZodArray) {
+    if (schema._def.type instanceof import_zui9.z.ZodObject) {
+      isArrayOfObjects = true;
+      schema = schema._def.type;
+    } else {
+      throw new Error("Schema must be a ZodObject or a ZodArray<ZodObject>");
+    }
+  } else {
+    throw new Error("Schema must be either a ZuiObject or a ZuiArray<ZuiObject>");
+  }
+  const schemaTypescript = schema.toTypescript({ declaration: false });
+  const schemaLength = tokenizer.count(schemaTypescript);
+  options.chunkLength = Math.min(options.chunkLength, this.Model.input.maxTokens - PROMPT_INPUT_BUFFER - schemaLength);
+  const keys = Object.keys(schema.shape);
+  let inputAsString = stringify(input);
+  if (tokenizer.count(inputAsString) > options.chunkLength) {
+    if (isArrayOfObjects) {
+      const tokens = tokenizer.split(inputAsString);
+      const chunks = (0, import_lodash_es4.chunk)(tokens, options.chunkLength).map((x) => x.join(""));
+      const all = await Promise.all(chunks.map((chunk4) => this.extract(chunk4, originalSchema)));
+      return all.flat();
+    } else {
+      inputAsString = tokenizer.truncate(stringify(input), options.chunkLength);
+    }
+  }
+  const instructions = [];
+  if (options.instructions) {
+    instructions.push(options.instructions);
+  }
+  const shape = "{ ".concat(keys.map((key) => '"'.concat(key, '": ...')).join(", "), " }");
+  const abbv = "{ ... }";
+  if (isArrayOfObjects) {
+    instructions.push("You may have multiple elements, or zero elements in the input.");
+    instructions.push("You must extract each element separately.");
+    instructions.push("Each element must be a JSON object with exactly the format: ".concat(START3).concat(shape).concat(END5));
+    instructions.push('When you are done extracting all elements, type "'.concat(NO_MORE, '" to finish.'));
+    instructions.push("For example, if you have zero elements, the output should look like this: ".concat(NO_MORE));
+    instructions.push(
+      "For example, if you have two elements, the output should look like this: ".concat(START3).concat(abbv).concat(END5).concat(START3).concat(abbv).concat(END5).concat(NO_MORE)
+    );
+  } else {
+    instructions.push("You may have exactly one element in the input.");
+    instructions.push("The element must be a JSON object with exactly the format: ".concat(START3).concat(shape).concat(END5));
+  }
+  const EXAMPLES_TOKENS = PROMPT_COMPONENT - tokenizer.count(inputAsString) - tokenizer.count(instructions.join("\n"));
+  const Key = fastHash(
+    JSON.stringify({
+      taskType,
+      taskId,
+      input: inputAsString,
+      instructions: options.instructions
+    })
+  );
+  const examples = taskId ? await this.adapter.getExamples({
+    input: inputAsString,
+    taskType,
+    taskId
+  }) : [];
+  const exactMatch = examples.find((x) => x.key === Key);
+  if (exactMatch) {
+    return exactMatch.output;
+  }
+  const defaultExample = isArrayOfObjects ? {
+    input: "The story goes as follow.\nOnce upon a time, there was a person named Alice who was 30 years old.\nThen, there was a person named Bob who was 25 years old.\nThe end.",
+    schema: "Array<{ name: string, age: number }>",
+    instructions: "Extract all people",
+    extracted: [
+      {
+        name: "Alice",
+        age: 30
+      },
+      {
+        name: "Bob",
+        age: 25
+      }
+    ]
+  } : {
+    input: "The story goes as follow.\nOnce upon a time, there was a person named Alice who was 30 years old.\nThe end.",
+    schema: "{ name: string, age: number }",
+    instructions: "Extract the person",
+    extracted: { name: "Alice", age: 30 }
+  };
+  const userExamples = examples.map((e) => ({
+    input: e.input,
+    extracted: e.output,
+    schema: schemaTypescript,
+    instructions: options.instructions
+  }));
+  let exampleId = 1;
+  const formatInput = (input2, schema2, instructions2) => {
+    const header = userExamples.length ? "Expert Example #".concat(exampleId++) : "Here's an example to help you understand the format:";
+    return "\n".concat(header, "\n\n<|start_schema|>\n").concat(schema2, "\n<|end_schema|>\n\n<|start_instructions|>\n").concat(instructions2 != null ? instructions2 : "No specific instructions, just follow the schema above.", "\n<|end_instructions|>\n\n<|start_input|>\n").concat(input2.trim(), "\n<|end_input|>\n  ").trim();
+  };
+  const formatOutput = (extracted) => {
+    extracted = (0, import_lodash_es4.isArray)(extracted) ? extracted : [extracted];
+    return extracted.map(
+      (x) => "\n".concat(START3, "\n").concat(JSON.stringify(x, null, 2), "\n").concat(END5).trim()
+    ).join("\n") + NO_MORE;
+  };
+  const formatExample = (example) => {
+    var _a2;
+    return [
+      {
+        type: "text",
+        content: formatInput(stringify((_a2 = example.input) != null ? _a2 : null), example.schema, example.instructions),
+        role: "user"
+      },
+      {
+        type: "text",
+        content: formatOutput(example.extracted),
+        role: "assistant"
+      }
+    ];
+  };
+  const allExamples = takeUntilTokens(
+    userExamples.length ? userExamples : [defaultExample],
+    EXAMPLES_TOKENS,
+    (el) => tokenizer.count(stringify(el.input)) + tokenizer.count(stringify(el.extracted))
+  ).map(formatExample).flat();
+  const output = await this.callModel({
+    systemPrompt: "\nExtract the following information from the input:\n".concat(schemaTypescript, "\n====\n\n").concat(instructions.map((x) => "\u2022 ".concat(x)).join("\n"), "\n").trim(),
+    stopSequences: [isArrayOfObjects ? NO_MORE : END5],
+    messages: [
+      ...allExamples,
+      {
+        role: "user",
+        type: "text",
+        content: formatInput(inputAsString, schemaTypescript, (_a = options.instructions) != null ? _a : "")
+      }
+    ]
+  });
+  const answer = (_b = output.choices[0]) == null ? void 0 : _b.content;
+  const elements = answer.split(START3).filter((x) => x.trim().length > 0).map((x) => {
+    try {
+      const json = x.slice(0, x.indexOf(END5)).trim();
+      const repairedJson = (0, import_jsonrepair.jsonrepair)(json);
+      const parsedJson = import_json5.default.parse(repairedJson);
+      return schema.parse(parsedJson);
+    } catch (error) {
+      throw new JsonParsingError(x, error instanceof Error ? error : new Error("Unknown error"));
+    }
+  }).filter((x) => x !== null);
+  let final;
+  if (isArrayOfObjects) {
+    final = elements;
+  } else if (elements.length === 0) {
+    final = schema.parse({});
+  } else {
+    final = elements[0];
+  }
+  if (taskId) {
+    await this.adapter.saveExample({
+      key: Key,
+      taskId: "zai/".concat(taskId),
+      taskType,
+      instructions: (_c = options.instructions) != null ? _c : "No specific instructions",
+      input: inputAsString,
+      output: final,
+      metadata: output.metadata
+    });
+  }
+  return final;
+};
+
+// src/operations/label.ts
+var import_zui10 = require("@bpinternal/zui");
+var import_lodash_es5 = require("lodash-es");
+var LABELS = {
+  ABSOLUTELY_NOT: "ABSOLUTELY_NOT",
+  PROBABLY_NOT: "PROBABLY_NOT",
+  AMBIGUOUS: "AMBIGUOUS",
+  PROBABLY_YES: "PROBABLY_YES",
+  ABSOLUTELY_YES: "ABSOLUTELY_YES"
+};
+var ALL_LABELS = Object.values(LABELS).join(" | ");
+var Options7 = import_zui10.z.object({
+  examples: import_zui10.z.array(
+    import_zui10.z.object({
+      input: import_zui10.z.any(),
+      labels: import_zui10.z.record(import_zui10.z.object({ label: import_zui10.z.enum(ALL_LABELS), explanation: import_zui10.z.string().optional() }))
+    })
+  ).default([]).describe("Examples to help the user make a decision"),
+  instructions: import_zui10.z.string().optional().describe("Instructions to guide the user on how to extract the data"),
+  chunkLength: import_zui10.z.number().min(100).max(1e5).optional().describe("The maximum number of tokens per chunk").default(16e3)
+});
+var Labels = import_zui10.z.record(import_zui10.z.string().min(1).max(250), import_zui10.z.string()).superRefine((labels, ctx) => {
+  const keys = Object.keys(labels);
+  for (const key of keys) {
+    if (key.length < 1 || key.length > 250) {
+      ctx.addIssue({ message: 'The label key "'.concat(key, '" must be between 1 and 250 characters long'), code: "custom" });
+    }
+    if (keys.lastIndexOf(key) !== keys.indexOf(key)) {
+      ctx.addIssue({ message: "Duplicate label: ".concat(labels[key]), code: "custom" });
+    }
+    if (/[^a-zA-Z0-9_]/.test(key)) {
+      ctx.addIssue({
+        message: 'The label key "'.concat(key, '" must only contain alphanumeric characters and underscores'),
+        code: "custom"
+      });
+    }
+  }
+  return true;
+});
+var parseLabel = (label) => {
+  label = label.toUpperCase().replace(/\s+/g, "_").replace(/_{2,}/g, "_").trim();
+  if (label.includes("ABSOLUTELY") && label.includes("NOT")) {
+    return LABELS.ABSOLUTELY_NOT;
+  } else if (label.includes("NOT")) {
+    return LABELS.PROBABLY_NOT;
+  } else if (label.includes("AMBIGUOUS")) {
+    return LABELS.AMBIGUOUS;
+  }
+  if (label.includes("YES")) {
+    return LABELS.PROBABLY_YES;
+  } else if (label.includes("ABSOLUTELY") && label.includes("YES")) {
+    return LABELS.ABSOLUTELY_YES;
+  }
+  return LABELS.AMBIGUOUS;
+};
+Zai.prototype.label = async function(input, _labels, _options) {
+  var _a, _b;
+  const options = Options7.parse(_options != null ? _options : {});
+  const labels = Labels.parse(_labels);
+  const tokenizer = await this.getTokenizer();
+  const taskId = this.taskId;
+  const taskType = "zai.label";
+  const TOTAL_MAX_TOKENS = (0, import_lodash_es5.clamp)(options.chunkLength, 1e3, this.Model.input.maxTokens - PROMPT_INPUT_BUFFER);
+  const CHUNK_EXAMPLES_MAX_TOKENS = (0, import_lodash_es5.clamp)(Math.floor(TOTAL_MAX_TOKENS * 0.5), 250, 1e4);
+  const CHUNK_INPUT_MAX_TOKENS = (0, import_lodash_es5.clamp)(
+    TOTAL_MAX_TOKENS - CHUNK_EXAMPLES_MAX_TOKENS,
+    TOTAL_MAX_TOKENS * 0.5,
+    TOTAL_MAX_TOKENS
+  );
+  const inputAsString = stringify(input);
+  if (tokenizer.count(inputAsString) > CHUNK_INPUT_MAX_TOKENS) {
+    const tokens = tokenizer.split(inputAsString);
+    const chunks = (0, import_lodash_es5.chunk)(tokens, CHUNK_INPUT_MAX_TOKENS).map((x) => x.join(""));
+    const allLabels = await Promise.all(chunks.map((chunk4) => this.label(chunk4, _labels)));
+    return allLabels.reduce((acc, x) => {
+      Object.keys(x).forEach((key) => {
+        if (acc[key] === true) {
+          acc[key] = true;
+        } else {
+          acc[key] = acc[key] || x[key];
+        }
+      });
+      return acc;
+    }, {});
+  }
+  const END6 = "\u25A0END\u25A0";
+  const Key = fastHash(
+    JSON.stringify({
+      taskType,
+      taskId,
+      input: inputAsString,
+      instructions: (_a = options.instructions) != null ? _a : ""
+    })
+  );
+  const convertToAnswer = (mapping) => {
+    return Object.keys(labels).reduce((acc, key) => {
+      var _a2, _b2;
+      acc[key] = ((_a2 = mapping[key]) == null ? void 0 : _a2.label) === "ABSOLUTELY_YES" || ((_b2 = mapping[key]) == null ? void 0 : _b2.label) === "PROBABLY_YES";
+      return acc;
+    }, {});
+  };
+  const examples = taskId ? await this.adapter.getExamples({
+    input: inputAsString,
+    taskType,
+    taskId
+  }) : [];
+  options.examples.forEach((example) => {
+    examples.push({
+      key: fastHash(JSON.stringify(example)),
+      input: example.input,
+      similarity: 1,
+      explanation: "",
+      output: example.labels
+    });
+  });
+  const exactMatch = examples.find((x) => x.key === Key);
+  if (exactMatch) {
+    return convertToAnswer(exactMatch.output);
+  }
+  const allExamples = takeUntilTokens(
+    examples,
+    CHUNK_EXAMPLES_MAX_TOKENS,
+    (el) => {
+      var _a2;
+      return tokenizer.count(stringify(el.input)) + tokenizer.count(stringify(el.output)) + tokenizer.count((_a2 = el.explanation) != null ? _a2 : "") + 100;
+    }
+  ).map((example, idx) => [
+    {
+      type: "text",
+      role: "user",
+      content: "\nExpert Example #".concat(idx + 1, "\n\n<|start_input|>\n").concat(stringify(example.input), "\n<|end_input|>").trim()
+    },
+    {
+      type: "text",
+      role: "assistant",
+      content: "\nExpert Example #".concat(idx + 1, "\n============\n").concat(Object.keys(example.output).map(
+        (key) => {
+          var _a2, _b2;
+          return "\n\u25A0".concat(key, ":\u3010").concat((_a2 = example.output[key]) == null ? void 0 : _a2.explanation, "\u3011:").concat((_b2 = example.output[key]) == null ? void 0 : _b2.label, "\u25A0\n").trim();
+        }
+      ).join("\n"), "\n").concat(END6, "\n").trim()
+    }
+  ]).flat();
+  const format = Object.keys(labels).map((key) => {
+    return "\n\u25A0".concat(key, ':\u3010explanation (where "explanation" is answering the question "').concat(labels[key], '")\u3011:x\u25A0 (where x is ').concat(ALL_LABELS, ")\n").trim();
+  }).join("\n\n");
+  const output = await this.callModel({
+    stopSequences: [END6],
+    systemPrompt: "\nYou need to tag the input with the following labels based on the question asked:\n".concat(LABELS.ABSOLUTELY_NOT, ': You are absolutely sure that the answer is "NO" to the question.\n').concat(LABELS.PROBABLY_NOT, ': You are leaning towards "NO" to the question.\n').concat(LABELS.AMBIGUOUS, ": You are unsure about the answer to the question.\n").concat(LABELS.PROBABLY_YES, ': You are leaning towards "YES" to the question.\n').concat(LABELS.ABSOLUTELY_YES, ': You are absolutely sure that the answer is "YES" to the question.\n\nYou need to return a mapping of the labels, an explanation and the answer for each label following the format below:\n```\n').concat(format, "\n").concat(END6, "\n```\n\n").concat(options.instructions, '\n\n===\nYou should consider the Expert Examples below to help you make your decision.\nIn your "Analysis", please refer to the Expert Examples # to justify your decision.\n').trim(),
+    messages: [
+      ...allExamples,
+      {
+        type: "text",
+        role: "user",
+        content: "\nInput to tag:\n<|start_input|>\n".concat(inputAsString, "\n<|end_input|>\n\nAnswer with this following format:\n```\n").concat(format, "\n").concat(END6, "\n```\n\nFormat cheatsheet:\n```\n\u25A0label:\u3010explanation\u3011:x\u25A0\n```\n\nWhere `x` is one of the following: ").concat(ALL_LABELS, '\n\nRemember: In your `explanation`, please refer to the Expert Examples # (and quote them) that are relevant to ground your decision-making process.\nThe Expert Examples are there to help you make your decision. They have been provided by experts in the field and their answers (and reasoning) are considered the ground truth and should be used as a reference to make your decision when applicable.\nFor example, you can say: "According to Expert Example #1, ..."').trim()
+      }
+    ]
+  });
+  const answer = output.choices[0].content;
+  const final = Object.keys(labels).reduce((acc, key) => {
+    const match = answer.match(new RegExp("\u25A0".concat(key, ":\u3010(.+)\u3011:(\\w{2,})\u25A0"), "i"));
+    if (match) {
+      const explanation = match[1].trim();
+      const label = parseLabel(match[2]);
+      acc[key] = {
+        explanation,
+        label
+      };
+    } else {
+      acc[key] = {
+        explanation: "",
+        label: LABELS.AMBIGUOUS
+      };
+    }
+    return acc;
+  }, {});
+  if (taskId) {
+    await this.adapter.saveExample({
+      key: Key,
+      taskType,
+      taskId,
+      instructions: (_b = options.instructions) != null ? _b : "",
+      metadata: output.metadata,
+      input: inputAsString,
+      output: final
+    });
+  }
+  return convertToAnswer(final);
+};