@botpress/zai 2.0.16 → 2.1.0

package/dist/operations/filter.js

@@ -1,5 +1,8 @@
 import { z } from "@bpinternal/zui";
 import { clamp } from "lodash-es";
+import { ZaiContext } from "../context";
+import { Response } from "../response";
+import { getTokenizer } from "../tokenizer";
 import { fastHash, stringify, takeUntilTokens } from "../utils";
 import { Zai } from "../zai";
 import { PROMPT_INPUT_BUFFER, PROMPT_OUTPUT_BUFFER } from "./constants";
@@ -13,14 +16,15 @@ const _Options = z.object({
   examples: z.array(_Example).describe("Examples to filter the condition against").default([])
 });
 const END = "\u25A0END\u25A0";
-Zai.prototype.filter = async function(input, condition, _options) {
+const filter = async (input, condition, _options, ctx) => {
+  ctx.controller.signal.throwIfAborted();
   const options = _Options.parse(_options ?? {});
-  const tokenizer = await this.getTokenizer();
-  await this.fetchModelDetails();
-  const taskId = this.taskId;
+  const tokenizer = await getTokenizer();
+  const model = await ctx.getModel();
+  const taskId = ctx.taskId;
   const taskType = "zai.filter";
   const MAX_ITEMS_PER_CHUNK = 50;
-  const TOKENS_TOTAL_MAX = this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER - PROMPT_OUTPUT_BUFFER;
+  const TOKENS_TOTAL_MAX = 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 = clamp(TOKENS_TOTAL_MAX * 0.25, 250, tokenizer.count(condition));
   const TOKENS_INPUT_ARRAY_MAX = TOKENS_TOTAL_MAX - TOKENS_EXAMPLES_MAX - TOKENS_CONDITION_MAX;
@@ -97,7 +101,7 @@ ${examples.map((x, idx) => `\u25A0${idx}:${!!x.filter ? "true" : "false"}:${x.re
     }
   ];
   const filterChunk = async (chunk) => {
-    const examples = taskId ? await this.adapter.getExamples({
+    const examples = taskId && ctx.adapter ? await ctx.adapter.getExamples({
       // The Table API can't search for a huge input string
       input: JSON.stringify(chunk).slice(0, 1e3),
       taskType,
@@ -122,7 +126,7 @@ ${examples.map((x, idx) => `\u25A0${idx}:${!!x.filter ? "true" : "false"}:${x.re
         role: "assistant"
       }
     ];
-    const { output, meta } = await this.callModel({
+    const { extracted: partial, meta } = await ctx.generateContent({
       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:
@@ -144,17 +148,18 @@ The condition is: "${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((_, idx) => {
-      return indices.find((x) => x.idx === idx)?.filter ?? false;
+      ],
+      transform: (text) => {
+        const indices = text.trim().split("\u25A0").filter((x) => x.length > 0).map((x) => {
+          const [idx, filter2] = x.split(":");
+          return { idx: parseInt(idx?.trim() ?? ""), filter: filter2?.toLowerCase().trim() === "true" };
+        });
+        return chunk.filter((_, idx) => {
+          return indices.find((x) => x.idx === idx && x.filter) ?? false;
+        });
+      }
     });
-    if (taskId) {
+    if (taskId && ctx.adapter && !ctx.controller.signal.aborted) {
       const key = fastHash(
         stringify({
           taskId,
@@ -163,7 +168,7 @@ The condition is: "${condition}"
           condition
         })
       );
-      await this.adapter.saveExample({
+      await ctx.adapter.saveExample({
         key,
         taskType,
         taskId,
@@ -176,7 +181,7 @@ The condition is: "${condition}"
             output: meta.cost.output
           },
           latency: meta.latency,
-          model: this.Model,
+          model: ctx.modelId,
           tokens: {
             input: meta.tokens.input,
             output: meta.tokens.output
@@ -189,3 +194,13 @@ The condition is: "${condition}"
   const filteredChunks = await Promise.all(chunks.map(filterChunk));
   return filteredChunks.flat();
 };
+Zai.prototype.filter = function(input, condition, _options) {
+  const context = new ZaiContext({
+    client: this.client,
+    modelId: this.Model,
+    taskId: this.taskId,
+    taskType: "zai.filter",
+    adapter: this.adapter
+  });
+  return new Response(context, filter(input, condition, _options, context), (result) => result);
+};

package/dist/operations/label.js

@@ -1,5 +1,8 @@
 import { z } from "@bpinternal/zui";
-import { clamp, chunk } from "lodash-es";
+import { chunk, clamp } from "lodash-es";
+import { ZaiContext } from "../context";
+import { Response } from "../response";
+import { getTokenizer } from "../tokenizer";
 import { fastHash, stringify, takeUntilTokens } from "../utils";
 import { Zai } from "../zai";
 import { PROMPT_INPUT_BUFFER } from "./constants";
@@ -39,24 +42,24 @@ const _Labels = z.record(z.string().min(1).max(250), z.string()).superRefine((la
   }
   return true;
 });
-const parseLabel = (label) => {
-  label = label.toUpperCase().replace(/\s+/g, "_").replace(/_{2,}/g, "_").trim();
-  if (label.includes("ABSOLUTELY") && label.includes("NOT")) {
+const parseLabel = (label2) => {
+  label2 = label2.toUpperCase().replace(/\s+/g, "_").replace(/_{2,}/g, "_").trim();
+  if (label2.includes("ABSOLUTELY") && label2.includes("NOT")) {
     return LABELS.ABSOLUTELY_NOT;
-  } else if (label.includes("NOT")) {
+  } else if (label2.includes("NOT")) {
     return LABELS.PROBABLY_NOT;
-  } else if (label.includes("AMBIGUOUS")) {
+  } else if (label2.includes("AMBIGUOUS")) {
     return LABELS.AMBIGUOUS;
   }
-  if (label.includes("YES")) {
+  if (label2.includes("YES")) {
     return LABELS.PROBABLY_YES;
-  } else if (label.includes("ABSOLUTELY") && label.includes("YES")) {
+  } else if (label2.includes("ABSOLUTELY") && label2.includes("YES")) {
     return LABELS.ABSOLUTELY_YES;
   }
   return LABELS.AMBIGUOUS;
 };
-const getConfidence = (label) => {
-  switch (label) {
+const getConfidence = (label2) => {
+  switch (label2) {
     case LABELS.ABSOLUTELY_NOT:
     case LABELS.ABSOLUTELY_YES:
       return 1;
@@ -67,14 +70,15 @@ const getConfidence = (label) => {
       return 0;
   }
 };
-Zai.prototype.label = async function(input, _labels, _options) {
+const label = async (input, _labels, _options, ctx) => {
+  ctx.controller.signal.throwIfAborted();
   const options = _Options.parse(_options ?? {});
   const labels = _Labels.parse(_labels);
-  const tokenizer = await this.getTokenizer();
-  await this.fetchModelDetails();
-  const taskId = this.taskId;
+  const tokenizer = await getTokenizer();
+  const model = await ctx.getModel();
+  const taskId = ctx.taskId;
   const taskType = "zai.label";
-  const TOTAL_MAX_TOKENS = clamp(options.chunkLength, 1e3, this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER);
+  const TOTAL_MAX_TOKENS = clamp(options.chunkLength, 1e3, model.input.maxTokens - PROMPT_INPUT_BUFFER);
   const CHUNK_EXAMPLES_MAX_TOKENS = clamp(Math.floor(TOTAL_MAX_TOKENS * 0.5), 250, 1e4);
   const CHUNK_INPUT_MAX_TOKENS = clamp(
     TOTAL_MAX_TOKENS - CHUNK_EXAMPLES_MAX_TOKENS,
@@ -85,7 +89,7 @@ Zai.prototype.label = async function(input, _labels, _options) {
   if (tokenizer.count(inputAsString) > CHUNK_INPUT_MAX_TOKENS) {
     const tokens = tokenizer.split(inputAsString);
     const chunks = chunk(tokens, CHUNK_INPUT_MAX_TOKENS).map((x) => x.join(""));
-    const allLabels = await Promise.all(chunks.map((chunk2) => this.label(chunk2, _labels)));
+    const allLabels = await Promise.all(chunks.map((chunk2) => label(chunk2, _labels, _options, ctx)));
     return allLabels.reduce((acc, x) => {
       Object.keys(x).forEach((key) => {
         if (acc[key]?.value === true) {
@@ -118,7 +122,7 @@ Zai.prototype.label = async function(input, _labels, _options) {
       return acc;
     }, {});
   };
-  const examples = taskId ? await this.adapter.getExamples({
+  const examples = taskId && ctx.adapter ? await ctx.adapter.getExamples({
     input: inputAsString,
     taskType,
     taskId
@@ -171,7 +175,7 @@ ${END}
 \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, meta } = await this.callModel({
+  const { extracted, meta } = await ctx.generateContent({
     stopSequences: [END],
     systemPrompt: `
 You need to tag the input with the following labels based on the question asked:
@@ -221,28 +225,27 @@ Remember: In your \`explanation\`, please refer to the Expert Examples # (and qu
 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()
       }
-    ]
+    ],
+    transform: (text) => Object.keys(labels).reduce((acc, key) => {
+      const match = text.match(new RegExp(`\u25A0${key}:\u3010(.+)\u3011:(\\w{2,})\u25A0`, "i"));
+      if (match) {
+        const explanation = match[1].trim();
+        const label2 = parseLabel(match[2]);
+        acc[key] = {
+          explanation,
+          label: label2
+        };
+      } else {
+        acc[key] = {
+          explanation: "",
+          label: LABELS.AMBIGUOUS
+        };
+      }
+      return acc;
+    }, {})
   });
-  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({
+  if (taskId && ctx.adapter && !ctx.controller.signal.aborted) {
+    await ctx.adapter.saveExample({
       key: Key,
       taskType,
       taskId,
@@ -253,15 +256,35 @@ For example, you can say: "According to Expert Example #1, ..."`.trim()
           output: meta.cost.output
         },
         latency: meta.latency,
-        model: this.Model,
+        model: ctx.modelId,
         tokens: {
           input: meta.tokens.input,
           output: meta.tokens.output
         }
       },
       input: inputAsString,
-      output: final
+      output: extracted
     });
   }
-  return convertToAnswer(final);
+  return convertToAnswer(extracted);
+};
+Zai.prototype.label = function(input, labels, _options) {
+  const context = new ZaiContext({
+    client: this.client,
+    modelId: this.Model,
+    taskId: this.taskId,
+    taskType: "zai.label",
+    adapter: this.adapter
+  });
+  return new Response(
+    context,
+    label(input, labels, _options, context),
+    (result) => Object.keys(result).reduce(
+      (acc, key) => {
+        acc[key] = result[key].value;
+        return acc;
+      },
+      {}
+    )
+  );
 };

package/dist/operations/rewrite.js

@@ -1,4 +1,7 @@
 import { z } from "@bpinternal/zui";
+import { ZaiContext } from "../context";
+import { Response } from "../response";
+import { getTokenizer } from "../tokenizer";
 import { fastHash, stringify, takeUntilTokens } from "../utils";
 import { Zai } from "../zai";
 import { PROMPT_INPUT_BUFFER } from "./constants";
@@ -12,19 +15,20 @@ const Options = z.object({
 });
 const START = "\u25A0START\u25A0";
 const END = "\u25A0END\u25A0";
-Zai.prototype.rewrite = async function(original, prompt, _options) {
+const rewrite = async (original, prompt, _options, ctx) => {
+  ctx.controller.signal.throwIfAborted();
   const options = Options.parse(_options ?? {});
-  const tokenizer = await this.getTokenizer();
-  await this.fetchModelDetails();
-  const taskId = this.taskId;
+  const tokenizer = await getTokenizer();
+  const model = await ctx.getModel();
+  const taskId = ctx.taskId;
   const taskType = "zai.rewrite";
-  const INPUT_COMPONENT_SIZE = Math.max(100, (this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER) / 2);
+  const INPUT_COMPONENT_SIZE = Math.max(100, (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.ModelDetails.input.maxTokens - tokenizer.count(prompt) - PROMPT_INPUT_BUFFER;
+  const maxInputSize = 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.ModelDetails.name} = ${this.ModelDetails.input.maxTokens} tokens)`
+      `The input size is ${inputSize} tokens long, which is more than the maximum of ${maxInputSize} tokens for this model (${model.name} = ${model.input.maxTokens} tokens)`
     );
   }
   const instructions = [];
@@ -52,17 +56,17 @@ ${END}
       prompt
     })
   );
-  const formatExample = ({ input, output: output2, instructions: instructions2 }) => {
+  const formatExample = ({ input, output, instructions: instructions2 }) => {
     return [
       { type: "text", role: "user", content: format(input, instructions2 || prompt) },
-      { type: "text", role: "assistant", content: `${START}${output2}${END}` }
+      { type: "text", role: "assistant", content: `${START}${output}${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({
+  const tableExamples = taskId && ctx.adapter ? await ctx.adapter.getExamples({
     input: original,
     taskId,
     taskType
@@ -75,30 +79,36 @@ ${END}
     ...tableExamples.map((x) => ({ input: x.input, output: x.output })),
     ...options.examples
   ];
-  const REMAINING_TOKENS = this.ModelDetails.input.maxTokens - tokenizer.count(prompt) - PROMPT_INPUT_BUFFER;
+  const REMAINING_TOKENS = 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, meta } = await this.callModel({
+  const { extracted, meta } = await ctx.generateContent({
     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]
+    stopSequences: [END],
+    transform: (text) => {
+      if (!text.trim().length) {
+        throw new Error("The model did not return a valid rewrite. The response was empty.");
+      }
+      return text;
+    }
   });
-  let result = output.choices[0]?.content;
+  let result = extracted;
   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({
+  if (taskId && ctx.adapter && !ctx.controller.signal.aborted) {
+    await ctx.adapter.saveExample({
       key: Key,
       metadata: {
         cost: {
@@ -106,7 +116,7 @@ ${instructions.map((x) => `\u2022 ${x}`).join("\n")}
           output: meta.cost.output
         },
         latency: meta.latency,
-        model: this.Model,
+        model: ctx.modelId,
         tokens: {
           input: meta.tokens.input,
           output: meta.tokens.output
@@ -121,3 +131,13 @@ ${instructions.map((x) => `\u2022 ${x}`).join("\n")}
   }
   return result;
 };
+Zai.prototype.rewrite = function(original, prompt, _options) {
+  const context = new ZaiContext({
+    client: this.client,
+    modelId: this.Model,
+    taskId: this.taskId,
+    taskType: "zai.rewrite",
+    adapter: this.adapter
+  });
+  return new Response(context, rewrite(original, prompt, _options, context), (result) => result);
+};

package/dist/operations/summarize.js

@@ -1,5 +1,8 @@
 import { z } from "@bpinternal/zui";
 import { chunk } from "lodash-es";
+import { ZaiContext } from "../context";
+import { Response } from "../response";
+import { getTokenizer } from "../tokenizer";
 import { Zai } from "../zai";
 import { PROMPT_INPUT_BUFFER, PROMPT_OUTPUT_BUFFER } from "./constants";
 const Options = z.object({
@@ -17,20 +20,20 @@ const Options = z.object({
 });
 const START = "\u25A0START\u25A0";
 const END = "\u25A0END\u25A0";
-Zai.prototype.summarize = async function(original, _options) {
-  const options = Options.parse(_options ?? {});
-  const tokenizer = await this.getTokenizer();
-  await this.fetchModelDetails();
-  const INPUT_COMPONENT_SIZE = Math.max(100, (this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER) / 4);
+const summarize = async (original, options, ctx) => {
+  ctx.controller.signal.throwIfAborted();
+  const tokenizer = await getTokenizer();
+  const model = await ctx.getModel();
+  const INPUT_COMPONENT_SIZE = Math.max(100, (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.ModelDetails.output.maxTokens - PROMPT_OUTPUT_BUFFER;
+  const maxOutputSize = 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.ModelDetails.output.maxTokens} tokens for this model (${this.ModelDetails.name})`
+      `The desired output length is ${maxOutputSize} tokens long, which is more than the maximum of ${model.output.maxTokens} tokens for this model (${model.name})`
     );
   }
-  options.sliding.window = Math.min(options.sliding.window, this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER);
+  options.sliding.window = Math.min(options.sliding.window, 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 `
@@ -52,8 +55,8 @@ ${newText}
   const chunkSize = Math.ceil(tokens.length / (parts * N));
   if (useMergeSort) {
     const chunks = chunk(tokens, chunkSize).map((x) => x.join(""));
-    const allSummaries = await Promise.all(chunks.map((chunk2) => this.summarize(chunk2, options)));
-    return this.summarize(allSummaries.join("\n\n============\n\n"), options);
+    const allSummaries = (await Promise.allSettled(chunks.map((chunk2) => summarize(chunk2, options, ctx)))).filter((x) => x.status === "fulfilled").map((x) => x.value);
+    return summarize(allSummaries.join("\n\n============\n\n"), options, ctx);
   }
   const summaries = [];
   let currentSummary = "";
@@ -103,7 +106,7 @@ ${newText}
         );
       }
     }
-    const { output } = await this.callModel({
+    let { extracted: result } = await ctx.generateContent({
       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).
@@ -117,9 +120,14 @@ ${options.format}
 `.trim(),
       messages: [{ type: "text", content: format(currentSummary, slice), role: "user" }],
       maxTokens: generationLength,
-      stopSequences: [END]
+      stopSequences: [END],
+      transform: (text) => {
+        if (!text.trim().length) {
+          throw new Error("The model did not return a valid summary. The response was empty.");
+        }
+        return text;
+      }
     });
-    let result = output?.choices[0]?.content;
     if (result.includes(START)) {
       result = result.slice(result.indexOf(START) + START.length);
     }
@@ -131,3 +139,14 @@ ${options.format}
   }
   return currentSummary.trim();
 };
+Zai.prototype.summarize = function(original, _options) {
+  const options = Options.parse(_options ?? {});
+  const context = new ZaiContext({
+    client: this.client,
+    modelId: this.Model,
+    taskId: this.taskId,
+    taskType: "summarize",
+    adapter: this.adapter
+  });
+  return new Response(context, summarize(original, options, context), (value) => value);
+};

package/dist/operations/text.js

@@ -1,17 +1,21 @@
 import { z } from "@bpinternal/zui";
 import { clamp } from "lodash-es";
+import { ZaiContext } from "../context";
+import { Response } from "../response";
+import { getTokenizer } from "../tokenizer";
 import { Zai } from "../zai";
 import { PROMPT_INPUT_BUFFER, PROMPT_OUTPUT_BUFFER } from "./constants";
 const Options = z.object({
   length: z.number().min(1).max(1e5).optional().describe("The maximum number of tokens to generate")
 });
-Zai.prototype.text = async function(prompt, _options) {
+const text = async (prompt, _options, ctx) => {
+  ctx.controller.signal.throwIfAborted();
   const options = Options.parse(_options ?? {});
-  const tokenizer = await this.getTokenizer();
-  await this.fetchModelDetails();
-  prompt = tokenizer.truncate(prompt, Math.max(this.ModelDetails.input.maxTokens - PROMPT_INPUT_BUFFER, 100));
+  const tokenizer = await getTokenizer();
+  const model = await ctx.getModel();
+  prompt = tokenizer.truncate(prompt, Math.max(model.input.maxTokens - PROMPT_INPUT_BUFFER, 100));
   if (options.length) {
-    options.length = Math.min(this.ModelDetails.output.maxTokens - PROMPT_OUTPUT_BUFFER, options.length);
+    options.length = Math.min(model.output.maxTokens - PROMPT_OUTPUT_BUFFER, options.length);
   }
   const instructions = [];
   let chart = "";
@@ -33,7 +37,7 @@ Zai.prototype.text = async function(prompt, _options) {
 | 200-300 tokens| A medium paragraph (150-200 words) |
 | 300-500 tokens| A long paragraph (200-300 words)   |`.trim();
   }
-  const { output } = await this.callModel({
+  const { extracted } = await ctx.generateContent({
     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")}
@@ -41,7 +45,23 @@ ${chart}
 `.trim(),
     temperature: 0.7,
     messages: [{ type: "text", content: prompt, role: "user" }],
-    maxTokens: options.length
+    maxTokens: options.length,
+    transform: (text2) => {
+      if (!text2.trim().length) {
+        throw new Error("The model did not return a valid summary. The response was empty.");
+      }
+      return text2;
+    }
   });
-  return output?.choices?.[0]?.content;
+  return extracted;
+};
+Zai.prototype.text = function(prompt, _options) {
+  const context = new ZaiContext({
+    client: this.client,
+    modelId: this.Model,
+    taskId: this.taskId,
+    taskType: "zai.text",
+    adapter: this.adapter
+  });
+  return new Response(context, text(prompt, _options, context), (result) => result);
 };

package/dist/response.js

@@ -0,0 +1,82 @@
+import { EventEmitter } from "./emitter";
+export class Response {
+  _promise;
+  _eventEmitter;
+  _context;
+  _elasped = null;
+  _simplify;
+  constructor(context, promise, simplify) {
+    this._context = context;
+    this._eventEmitter = new EventEmitter();
+    this._simplify = simplify;
+    this._promise = promise.then(
+      (value) => {
+        this._elasped ||= this._context.elapsedTime;
+        this._eventEmitter.emit("complete", value);
+        this._eventEmitter.clear();
+        this._context.clear();
+        return value;
+      },
+      (reason) => {
+        this._elasped ||= this._context.elapsedTime;
+        this._eventEmitter.emit("error", reason);
+        this._eventEmitter.clear();
+        this._context.clear();
+        throw reason;
+      }
+    );
+    this._context.on("update", (usage) => {
+      this._eventEmitter.emit("progress", usage);
+    });
+  }
+  // Event emitter methods
+  on(type, listener) {
+    this._eventEmitter.on(type, listener);
+    return this;
+  }
+  off(type, listener) {
+    this._eventEmitter.off(type, listener);
+    return this;
+  }
+  once(type, listener) {
+    this._eventEmitter.once(type, listener);
+    return this;
+  }
+  bindSignal(signal) {
+    if (signal.aborted) {
+      this.abort(signal.reason);
+    }
+    const signalAbort = () => {
+      this.abort(signal.reason);
+    };
+    signal.addEventListener("abort", () => signalAbort());
+    this.once("complete", () => signal.removeEventListener("abort", signalAbort));
+    this.once("error", () => signal.removeEventListener("abort", signalAbort));
+    return this;
+  }
+  abort(reason) {
+    this._context.controller.abort(reason);
+  }
+  then(onfulfilled, onrejected) {
+    return this._promise.then(
+      (value) => {
+        const simplified = this._simplify(value);
+        return onfulfilled ? onfulfilled(simplified) : simplified;
+      },
+      (reason) => {
+        if (onrejected) {
+          return onrejected(reason);
+        }
+        throw reason;
+      }
+    );
+  }
+  catch(onrejected) {
+    return this._promise.catch(onrejected);
+  }
+  async result() {
+    const output = await this._promise;
+    const usage = this._context.usage;
+    return { output, usage, elapsed: this._elasped };
+  }
+}

package/dist/tokenizer.js

@@ -0,0 +1,11 @@
+import { getWasmTokenizer } from "@bpinternal/thicktoken";
+let tokenizer = null;
+export async function getTokenizer() {
+  if (!tokenizer) {
+    while (!getWasmTokenizer) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    tokenizer = getWasmTokenizer();
+  }
+  return tokenizer;
+}