@botpress/zai 1.0.1 → 1.2.0

package/dist/index.js

@@ -1,1873 +1,9 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/zai.ts
-import sdk3 from "@botpress/sdk";
-import { getWasmTokenizer } from "@botpress/wasm";
-
-// src/adapters/botpress-table.ts
-import sdk2 from "@botpress/sdk";
-
-// src/utils.ts
-import sdk from "@botpress/sdk";
-var { z } = sdk;
-var stringify = /* @__PURE__ */ __name((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>";
-}, "stringify");
-var BotpressClient = 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);
-}
-__name(fastHash, "fastHash");
-var takeUntilTokens = /* @__PURE__ */ __name((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;
-}, "takeUntilTokens");
-var GenerationMetadata = z.object({
-  model: z.string(),
-  cost: z.object({
-    input: z.number(),
-    output: z.number()
-  }).describe("Cost in $USD"),
-  latency: z.number().describe("Latency in milliseconds"),
-  tokens: z.object({
-    input: z.number(),
-    output: z.number()
-  }).describe("Number of tokens used")
-});
-
-// src/adapters/adapter.ts
-var Adapter = class {
-  static {
-    __name(this, "Adapter");
-  }
-};
-
-// src/adapters/botpress-table.ts
-var { z: z2 } = sdk2;
-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 = z2.object({
-  client: BotpressClient,
-  tableName: z2.string().regex(
-    /^[a-zA-Z0-9_]{1,45}Table$/,
-    "Table name must be lowercase and contain only letters, numbers and underscores"
-  )
-});
-var TableSchema = z2.object({
-  taskType: z2.string().describe("The type of the task (filter, extract, etc.)"),
-  taskId: z2.string(),
-  key: z2.string().describe("A unique key for the task (e.g. a hash of the input, taskId, taskType and instructions)"),
-  instructions: z2.string(),
-  input: z2.object({}).passthrough().describe("The input to the task"),
-  output: z2.object({}).passthrough().describe("The expected output"),
-  explanation: z2.string().nullable(),
-  metadata: GenerationMetadata,
-  status: z2.enum(["pending", "rejected", "approved"]),
-  feedback: z2.object({
-    rating: z2.enum(["very-bad", "bad", "good", "very-good"]),
-    comment: z2.string().nullable()
-  }).nullable().default(null)
-});
-var searchableColumns = ["input"];
-var 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;
-}, {});
-var TableAdapter = class extends Adapter {
-  static {
-    __name(this, "TableAdapter");
-  }
-  client;
-  tableName;
-  status;
-  errors = [];
-  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((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 (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.errors = issues;
-      }
-    }
-    this.status = "initialized";
-  }
-};
-
-// src/adapters/memory.ts
-var MemoryAdapter = class extends Adapter {
-  constructor(examples) {
-    super();
-    this.examples = examples;
-  }
-  static {
-    __name(this, "MemoryAdapter");
-  }
-  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 { z: z3 } = sdk3;
-var ActiveLearning = z3.object({
-  enable: z3.boolean().describe("Whether to enable active learning").default(false),
-  tableName: z3.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: z3.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 = z3.object({
-  client: BotpressClient,
-  userId: z3.string().describe("The ID of the user consuming the API").optional(),
-  retry: z3.object({ maxRetries: z3.number().min(0).max(100) }).default({ maxRetries: 3 }),
-  modelId: z3.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: z3.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 {
-  static {
-    __name(this, "Zai");
-  }
-  static tokenizer = null;
-  client;
-  originalConfig;
-  userId;
-  integration;
-  model;
-  retry;
-  Model;
-  namespace;
-  adapter;
-  activeLearning;
-  constructor(config) {
-    this.originalConfig = config;
-    const parsed = ZaiConfig.parse(config);
-    this.client = parsed.client;
-    const [integration, modelId] = parsed.modelId.split("__");
-    if (!integration?.length || !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 = parsed.activeLearning?.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 }
-    });
-  }
-};
-
-// src/operations/text.ts
-import sdk4 from "@botpress/sdk";
-import _ from "lodash";
-
-// src/operations/constants.ts
-var PROMPT_INPUT_BUFFER = 1048;
-var PROMPT_OUTPUT_BUFFER = 512;
-
-// src/operations/text.ts
-var { z: z4 } = sdk4;
-var Options = z4.object({
-  length: z4.number().min(1).max(1e5).optional().describe("The maximum number of tokens to generate")
-});
-Zai.prototype.text = async function(prompt, _options) {
-  const options = Options.parse(_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 = _.clamp(options.length * 0.75, 5, options.length);
-    instructions.push(`IMPORTANT: Length constraint: ${length} tokens/words`);
-    instructions.push(`The text must be standalone and complete in less than ${length} tokens/words`);
-  }
-  if (options.length && options.length <= 500) {
-    chart = `
-| Tokens      | Text Length (approximate)            |
-|-------------|--------------------------------------|
-| < 5 tokens  | 1-3 words                            |
-| 5-10 tokens | 3-6 words                            |
-| 10-20 tokens| 6-15 words                           |
-| 20-50 tokens| A short sentence (15-30 words)       |
-| 50-100 tokens| A medium sentence (30-70 words)     |
-| 100-200 tokens| A short paragraph (70-150 words)   |
-| 200-300 tokens| A medium paragraph (150-200 words) |
-| 300-500 tokens| A long paragraph (200-300 words)   |`.trim();
-  }
-  const output = await this.callModel({
-    systemPrompt: `
-Generate 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.
-${instructions.map((x) => `- ${x}`).join("\n")}
-${chart}
-`.trim(),
-    temperature: 0.7,
-    messages: [{ type: "text", content: prompt, role: "user" }],
-    maxTokens: options.length
-  });
-  return output?.choices?.[0]?.content;
-};
-
-// src/operations/rewrite.ts
-import sdk5 from "@botpress/sdk";
-var { z: z5 } = sdk5;
-var Example = z5.object({
-  input: z5.string(),
-  output: z5.string()
-});
-var Options2 = z5.object({
-  examples: z5.array(Example).default([]),
-  length: z5.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) {
-  const options = Options2.parse(_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 ${inputSize} tokens long, which is more than the maximum of ${maxInputSize} tokens for this model (${this.Model.name} = ${this.Model.input.maxTokens} tokens)`
-    );
-  }
-  const instructions = [];
-  const originalSize = tokenizer.count(original);
-  if (options.length && originalSize > options.length) {
-    instructions.push(`The original text is ${originalSize} tokens long \u2013 it should be less than ${options.length}`);
-    instructions.push(
-      `The text must be standalone and complete in less than ${options.length} tokens, so it has to be shortened to fit the length as well`
-    );
-  }
-  const format = /* @__PURE__ */ __name((before, prompt2) => {
-    return `
-Prompt: ${prompt2}
-
-${START}
-${before}
-${END}
-`.trim();
-  }, "format");
-  const Key = fastHash(
-    stringify({
-      taskId,
-      taskType,
-      input: original,
-      prompt
-    })
-  );
-  const formatExample = /* @__PURE__ */ __name(({ input, output: output2, instructions: instructions2 }) => {
-    return [
-      { type: "text", role: "user", content: format(input, instructions2 || prompt) },
-      { type: "text", role: "assistant", content: `${START}${output2}${END}` }
-    ];
-  }, "formatExample");
-  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: `
-Rewrite the text between the ${START} and ${END} tags to match the user prompt.
-${instructions.map((x) => `\u2022 ${x}`).join("\n")}
-`.trim(),
-    messages: [...examples, { type: "text", content: format(original, prompt), role: "user" }],
-    maxTokens: options.length,
-    stopSequences: [END]
-  });
-  let result = output.choices[0]?.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
-import sdk6 from "@botpress/sdk";
-import _2 from "lodash";
-var { z: z6 } = sdk6;
-var Options3 = z6.object({
-  prompt: z6.string().describe("What should the text be summarized to?").default("New information, concepts and ideas that are deemed important"),
-  format: z6.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: z6.number().min(10).max(1e5).describe("The length of the summary in tokens").default(250),
-  intermediateFactor: z6.number().min(1).max(10).describe("How many times longer (than final length) are the intermediate summaries generated").default(4),
-  maxIterations: z6.number().min(1).default(100),
-  sliding: z6.object({
-    window: z6.number().min(10).max(1e5),
-    overlap: z6.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) {
-  const options = Options3.parse(_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 ${maxOutputSize} tokens long, which is more than the maximum of ${this.Model.output.maxTokens} tokens for this model (${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 = /* @__PURE__ */ __name((summary, newText) => {
-    return `
-${START2}
-${summary.length ? summary : "<summary still empty>"}
-${END2}
-
-Please amend the summary between the ${START2} and ${END2} tags to accurately reflect the prompt and the additional text below.
-
-<|start_new_information|>
-${newText}
-<|new_information|>`.trim();
-  }, "format");
-  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 = _2.chunk(tokens, chunkSize).map((x) => x.join(""));
-    const allSummaries = await Promise.all(chunks.map((chunk) => this.summarize(chunk, 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 ${START2} and ${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 ${currentSummary.length} tokens long.`);
-      instructions.push(`You can amend the summary to be up to ${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 ${currentSummary.length} tokens long. You need to make sure it is ${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 ${options.length} tokens while also including the new information.`
-        );
-      }
-    }
-    const output = await this.callModel({
-      systemPrompt: `
-You are summarizing a text. The text is split into ${parts} parts, and you are currently working on part ${iteration}.
-At 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).
-The summary needs to cover the main points of the text and must be concise.
-
-IMPORTANT INSTRUCTIONS:
-${instructions.map((x) => `- ${x.trim()}`).join("\n")}
-
-FORMAT OF THE SUMMARY:
-${options.format}
-`.trim(),
-      messages: [{ type: "text", content: format(currentSummary, slice), role: "user" }],
-      maxTokens: generationLength,
-      stopSequences: [END2]
-    });
-    let result = output?.choices[0]?.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
-import sdk7 from "@botpress/sdk";
-var { z: z7 } = sdk7;
-var Example2 = z7.object({
-  input: z7.any(),
-  check: z7.boolean(),
-  reason: z7.string().optional()
-});
-var Options4 = z7.object({
-  examples: z7.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) {
-  const options = Options4.parse(_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 = /* @__PURE__ */ __name((input2, condition2) => {
-    const header = userExamples.length ? `Expert Example #${exampleId++}` : `Example of condition: "${condition2}"`;
-    return `
-${header}
-<|start_input|>
-${input2.trim()}
-<|end_input|>
-`.trim();
-  }, "formatInput");
-  const formatOutput = /* @__PURE__ */ __name((answer2, justification) => {
-    return `
-Analysis: ${justification}
-Final Answer: ${answer2 ? TRUE : FALSE}
-${END3}
-`.trim();
-  }, "formatOutput");
-  const formatExample = /* @__PURE__ */ __name((example) => [
-    { type: "text", content: formatInput(stringify(example.input ?? null), condition), role: "user" },
-    {
-      type: "text",
-      content: formatOutput(example.check, example.reason ?? ""),
-      role: "assistant"
-    }
-  ], "formatExample");
-  const allExamples = takeUntilTokens(
-    userExamples.length ? userExamples : defaultExamples,
-    EXAMPLES_TOKENS,
-    (el) => tokenizer.count(stringify(el.input)) + tokenizer.count(el.reason ?? "")
-  ).map(formatExample).flat();
-  const specialInstructions = userExamples.length ? `
-- You have been provided with examples from previous experts. Make sure to read them carefully before making your decision.
-- Make sure to refer to the examples provided by the experts to justify your decision (when applicable).
-- When in doubt, ground your decision on the examples provided by the experts instead of your own intuition.
-- 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.
-`.trim() : "";
-  const output = await this.callModel({
-    systemPrompt: `
-Check if the following condition is true or false for the given input. Before answering, make sure to read the input and the condition carefully.
-Justify your answer, then answer with either ${TRUE} or ${FALSE} at the very end, then add ${END3} to finish the response.
-IMPORTANT: Make sure to answer with either ${TRUE} or ${FALSE} at the end of your response, but NOT both.
----
-Expert Examples (#1 to #${exampleId - 1}):
-${specialInstructions}
-`.trim(),
-    stopSequences: [END3],
-    messages: [
-      ...allExamples,
-      {
-        type: "text",
-        content: `
-Considering the below input and above examples, is the following condition true or false?
-${formatInput(inputAsString, condition)}
-In your "Analysis", please refer to the Expert Examples # to justify your decision.`.trim(),
-        role: "user"
-      }
-    ]
-  });
-  const answer = output.choices[0]?.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: ${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
-import sdk8 from "@botpress/sdk";
-import _3 from "lodash";
-var { z: z8 } = sdk8;
-var Example3 = z8.object({
-  input: z8.any(),
-  filter: z8.boolean(),
-  reason: z8.string().optional()
-});
-var Options5 = z8.object({
-  tokensPerItem: z8.number().min(1).max(1e5).optional().describe("The maximum number of tokens per item").default(250),
-  examples: z8.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 ?? {});
-  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 = _3.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 = /* @__PURE__ */ __name((input2, condition2) => {
-    return `
-Condition to check:
-${condition2}
-
-Items (from \u25A00 to \u25A0${input2.length - 1})
-==============================
-${input2.map((x, idx) => `\u25A0${idx} = ${stringify(x.input ?? null, false)}`).join("\n")}
-`.trim();
-  }, "formatInput");
-  const formatExamples = /* @__PURE__ */ __name((examples) => {
-    return `
-${examples.map((x, idx) => `\u25A0${idx}:${!!x.filter ? "true" : "false"}`).join("")}
-${END4}
-====
-Here's the reasoning behind each example:
-${examples.map((x, idx) => `\u25A0${idx}:${!!x.filter ? "true" : "false"}:${x.reason ?? "No reason provided"}`).join("\n")}
-`.trim();
-  }, "formatExamples");
-  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 = /* @__PURE__ */ __name(async (chunk) => {
-    const examples = taskId ? await this.adapter.getExamples({
-      // The Table API can't search for a huge input string
-      input: JSON.stringify(chunk).slice(0, 1e3),
-      taskType,
-      taskId
-    }).then(
-      (x) => x.map((y) => ({ filter: y.output, input: y.input, reason: y.explanation }))
-    ) : [];
-    const allExamples = takeUntilTokens(
-      [...examples, ...options.examples ?? []],
-      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: `
-You are given a list of items. Your task is to filter out the items that meet the condition below.
-You need to return the full list of items with the format:
-\u25A0x:true\u25A0y:false\u25A0z:true (where x, y, z are the indices of the items in the list)
-You need to start with "\u25A00" and go up to the last index "\u25A0${chunk.length - 1}".
-If an item meets the condition, you should return ":true", otherwise ":false".
-
-IMPORTANT: Make sure to read the condition and the examples carefully before making your decision.
-The condition is: "${condition}"
-`.trim(),
-      stopSequences: [END4],
-      messages: [
-        ...exampleMessages.length ? exampleMessages : genericExamplesMessages,
-        {
-          type: "text",
-          content: formatInput(
-            chunk.map((x) => ({ input: x })),
-            condition
-          ),
-          role: "user"
-        }
-      ]
-    });
-    const answer = output.choices[0]?.content;
-    const indices = answer.trim().split("\u25A0").filter((x) => x.length > 0).map((x) => {
-      const [idx, filter] = x.split(":");
-      return { idx: parseInt(idx?.trim() ?? ""), filter: filter?.toLowerCase().trim() === "true" };
-    });
-    const partial = chunk.filter((_6, idx) => {
-      return indices.find((x) => x.idx === idx)?.filter ?? false;
-    });
-    if (taskId) {
-      const key = fastHash(
-        stringify({
-          taskId,
-          taskType,
-          input: JSON.stringify(chunk),
-          condition
-        })
-      );
-      await this.adapter.saveExample({
-        key,
-        taskType,
-        taskId,
-        input: JSON.stringify(chunk),
-        output: partial,
-        instructions: condition,
-        metadata: output.metadata
-      });
-    }
-    return partial;
-  }, "filterChunk");
-  const filteredChunks = await Promise.all(chunks.map(filterChunk));
-  return filteredChunks.flat();
-};
-
-// src/operations/extract.ts
-import sdk9 from "@botpress/sdk";
-import JSON5 from "json5";
-import { jsonrepair } from "jsonrepair";
-import _4 from "lodash";
-
-// src/operations/errors.ts
-var JsonParsingError = class extends Error {
-  constructor(json, error) {
-    const message = `Error parsing JSON:
-
----JSON---
-${json}
-
----Error---
-
- ${error}`;
-    super(message);
-    this.json = json;
-    this.error = error;
-  }
-  static {
-    __name(this, "JsonParsingError");
-  }
-};
-
-// src/operations/extract.ts
-var { z: z9 } = sdk9;
-var Options6 = z9.object({
-  instructions: z9.string().optional().describe("Instructions to guide the user on how to extract the data"),
-  chunkLength: z9.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) {
-  const options = Options6.parse(_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 sdk9.ZodObject) {
-  } else if (schema instanceof sdk9.ZodArray) {
-    if (schema._def.type instanceof sdk9.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 = _4.chunk(tokens, options.chunkLength).map((x) => x.join(""));
-      const all = await Promise.all(chunks.map((chunk) => this.extract(chunk, originalSchema)));
-      return all.flat();
-    } else {
-      inputAsString = tokenizer.truncate(stringify(input), options.chunkLength);
-    }
-  }
-  const instructions = [];
-  if (options.instructions) {
-    instructions.push(options.instructions);
-  }
-  const shape = `{ ${keys.map((key) => `"${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: ${START3}${shape}${END5}`);
-    instructions.push(`When you are done extracting all elements, type "${NO_MORE}" to finish.`);
-    instructions.push(`For example, if you have zero elements, the output should look like this: ${NO_MORE}`);
-    instructions.push(
-      `For example, if you have two elements, the output should look like this: ${START3}${abbv}${END5}${START3}${abbv}${END5}${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: ${START3}${shape}${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.
-Once upon a time, there was a person named Alice who was 30 years old.
-Then, there was a person named Bob who was 25 years old.
-The 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.
-Once upon a time, there was a person named Alice who was 30 years old.
-The 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 = /* @__PURE__ */ __name((input2, schema2, instructions2) => {
-    const header = userExamples.length ? `Expert Example #${exampleId++}` : "Here's an example to help you understand the format:";
-    return `
-${header}
-
-<|start_schema|>
-${schema2}
-<|end_schema|>
-
-<|start_instructions|>
-${instructions2 ?? "No specific instructions, just follow the schema above."}
-<|end_instructions|>
-
-<|start_input|>
-${input2.trim()}
-<|end_input|>
-  `.trim();
-  }, "formatInput");
-  const formatOutput = /* @__PURE__ */ __name((extracted) => {
-    extracted = _4.isArray(extracted) ? extracted : [extracted];
-    return extracted.map(
-      (x) => `
-${START3}
-${JSON.stringify(x, null, 2)}
-${END5}`.trim()
-    ).join("\n") + NO_MORE;
-  }, "formatOutput");
-  const formatExample = /* @__PURE__ */ __name((example) => [
-    {
-      type: "text",
-      content: formatInput(stringify(example.input ?? null), example.schema, example.instructions),
-      role: "user"
-    },
-    {
-      type: "text",
-      content: formatOutput(example.extracted),
-      role: "assistant"
-    }
-  ], "formatExample");
-  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: `
-Extract the following information from the input:
-${schemaTypescript}
-====
-
-${instructions.map((x) => `\u2022 ${x}`).join("\n")}
-`.trim(),
-    stopSequences: [isArrayOfObjects ? NO_MORE : END5],
-    messages: [
-      ...allExamples,
-      {
-        role: "user",
-        type: "text",
-        content: formatInput(inputAsString, schemaTypescript, options.instructions ?? "")
-      }
-    ]
-  });
-  const answer = output.choices[0]?.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 = jsonrepair(json);
-      const parsedJson = JSON5.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/${taskId}`,
-      taskType,
-      instructions: options.instructions ?? "No specific instructions",
-      input: inputAsString,
-      output: final,
-      metadata: output.metadata
-    });
-  }
-  return final;
-};
-
-// src/operations/label.ts
-import sdk10 from "@botpress/sdk";
-import _5 from "lodash";
-var { z: z10 } = sdk10;
-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 = z10.object({
-  examples: z10.array(
-    z10.object({
-      input: z10.any(),
-      labels: z10.record(z10.object({ label: z10.enum(ALL_LABELS), explanation: z10.string().optional() }))
-    })
-  ).default([]).describe("Examples to help the user make a decision"),
-  instructions: z10.string().optional().describe("Instructions to guide the user on how to extract the data"),
-  chunkLength: z10.number().min(100).max(1e5).optional().describe("The maximum number of tokens per chunk").default(16e3)
-});
-var Labels = z10.record(z10.string().min(1).max(250), z10.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 "${key}" must be between 1 and 250 characters long`, code: "custom" });
-    }
-    if (keys.lastIndexOf(key) !== keys.indexOf(key)) {
-      ctx.addIssue({ message: `Duplicate label: ${labels[key]}`, code: "custom" });
-    }
-    if (/[^a-zA-Z0-9_]/.test(key)) {
-      ctx.addIssue({
-        message: `The label key "${key}" must only contain alphanumeric characters and underscores`,
-        code: "custom"
-      });
-    }
-  }
-  return true;
-});
-var parseLabel = /* @__PURE__ */ __name((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;
-}, "parseLabel");
-Zai.prototype.label = async function(input, _labels, _options) {
-  const options = Options7.parse(_options ?? {});
-  const labels = Labels.parse(_labels);
-  const tokenizer = await this.getTokenizer();
-  const taskId = this.taskId;
-  const taskType = "zai.label";
-  const TOTAL_MAX_TOKENS = _5.clamp(options.chunkLength, 1e3, this.Model.input.maxTokens - PROMPT_INPUT_BUFFER);
-  const CHUNK_EXAMPLES_MAX_TOKENS = _5.clamp(Math.floor(TOTAL_MAX_TOKENS * 0.5), 250, 1e4);
-  const CHUNK_INPUT_MAX_TOKENS = _5.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 = _5.chunk(tokens, CHUNK_INPUT_MAX_TOKENS).map((x) => x.join(""));
-    const allLabels = await Promise.all(chunks.map((chunk) => this.label(chunk, _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: options.instructions ?? ""
-    })
-  );
-  const convertToAnswer = /* @__PURE__ */ __name((mapping) => {
-    return Object.keys(labels).reduce((acc, key) => {
-      acc[key] = mapping[key]?.label === "ABSOLUTELY_YES" || mapping[key]?.label === "PROBABLY_YES";
-      return acc;
-    }, {});
-  }, "convertToAnswer");
-  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) => tokenizer.count(stringify(el.input)) + tokenizer.count(stringify(el.output)) + tokenizer.count(el.explanation ?? "") + 100
-  ).map((example, idx) => [
-    {
-      type: "text",
-      role: "user",
-      content: `
-Expert Example #${idx + 1}
-
-<|start_input|>
-${stringify(example.input)}
-<|end_input|>`.trim()
-    },
-    {
-      type: "text",
-      role: "assistant",
-      content: `
-Expert Example #${idx + 1}
-============
-${Object.keys(example.output).map(
-        (key) => `
-\u25A0${key}:\u3010${example.output[key]?.explanation}\u3011:${example.output[key]?.label}\u25A0
-`.trim()
-      ).join("\n")}
-${END6}
-`.trim()
-    }
-  ]).flat();
-  const format = Object.keys(labels).map((key) => {
-    return `
-\u25A0${key}:\u3010explanation (where "explanation" is answering the question "${labels[key]}")\u3011:x\u25A0 (where x is ${ALL_LABELS})
-`.trim();
-  }).join("\n\n");
-  const output = await this.callModel({
-    stopSequences: [END6],
-    systemPrompt: `
-You need to tag the input with the following labels based on the question asked:
-${LABELS.ABSOLUTELY_NOT}: You are absolutely sure that the answer is "NO" to the question.
-${LABELS.PROBABLY_NOT}: You are leaning towards "NO" to the question.
-${LABELS.AMBIGUOUS}: You are unsure about the answer to the question.
-${LABELS.PROBABLY_YES}: You are leaning towards "YES" to the question.
-${LABELS.ABSOLUTELY_YES}: You are absolutely sure that the answer is "YES" to the question.
-
-You need to return a mapping of the labels, an explanation and the answer for each label following the format below:
-\`\`\`
-${format}
-${END6}
-\`\`\`
-
-${options.instructions}
-
-===
-You should consider the Expert Examples below to help you make your decision.
-In your "Analysis", please refer to the Expert Examples # to justify your decision.
-`.trim(),
-    messages: [
-      ...allExamples,
-      {
-        type: "text",
-        role: "user",
-        content: `
-Input to tag:
-<|start_input|>
-${inputAsString}
-<|end_input|>
-
-Answer with this following format:
-\`\`\`
-${format}
-${END6}
-\`\`\`
-
-Format cheatsheet:
-\`\`\`
-\u25A0label:\u3010explanation\u3011:x\u25A0
-\`\`\`
-
-Where \`x\` is one of the following: ${ALL_LABELS}
-
-Remember: In your \`explanation\`, please refer to the Expert Examples # (and quote them) that are relevant to ground your decision-making process.
-The 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.
-For 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${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: options.instructions ?? "",
-      metadata: output.metadata,
-      input: inputAsString,
-      output: final
-    });
-  }
-  return convertToAnswer(final);
-};
-export {
-  Zai
-};
-//# sourceMappingURL=index.js.map
+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 };