@botpress/zai 1.0.1 → 1.1.0

package/dist/adapters/adapter.js

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

package/dist/adapters/botpress-table.js

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

package/dist/adapters/memory.js

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

package/dist/index.d.ts

@@ -1,32 +1,33 @@
+import * as _bpinternal_zui from '@bpinternal/zui';
+import { z } from '@bpinternal/zui';
 import { Client } from '@botpress/client';
-import sdk from '@botpress/sdk';
 import { TextTokenizer } from '@botpress/wasm';
 
-type GenerationMetadata = sdk.z.input<typeof GenerationMetadata>;
-declare const GenerationMetadata: sdk.ZodObject<{
-    model: sdk.ZodString;
-    cost: sdk.ZodObject<{
-        input: sdk.ZodNumber;
-        output: sdk.ZodNumber;
-    }, "strip", sdk.ZodTypeAny, {
+type GenerationMetadata = z.input<typeof GenerationMetadata>;
+declare const GenerationMetadata: _bpinternal_zui.ZodObject<{
+    model: _bpinternal_zui.ZodString;
+    cost: _bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodNumber;
+        output: _bpinternal_zui.ZodNumber;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: number;
         output?: number;
     }, {
         input?: number;
         output?: number;
     }>;
-    latency: sdk.ZodNumber;
-    tokens: sdk.ZodObject<{
-        input: sdk.ZodNumber;
-        output: sdk.ZodNumber;
-    }, "strip", sdk.ZodTypeAny, {
+    latency: _bpinternal_zui.ZodNumber;
+    tokens: _bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodNumber;
+        output: _bpinternal_zui.ZodNumber;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: number;
         output?: number;
     }, {
         input?: number;
         output?: number;
     }>;
-}, "strip", sdk.ZodTypeAny, {
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     model?: string;
     cost?: {
         input?: number;
@@ -558,12 +559,12 @@ declare namespace llm {
     }
 }
 
-type ActiveLearning = sdk.z.input<typeof ActiveLearning>;
-declare const ActiveLearning: sdk.ZodObject<{
-    enable: sdk.ZodDefault<sdk.ZodBoolean>;
-    tableName: sdk.ZodDefault<sdk.ZodString>;
-    taskId: sdk.ZodDefault<sdk.ZodString>;
-}, "strip", sdk.ZodTypeAny, {
+type ActiveLearning = z.input<typeof ActiveLearning>;
+declare const ActiveLearning: _bpinternal_zui.ZodObject<{
+    enable: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodBoolean>;
+    tableName: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+    taskId: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     tableName?: string;
     taskId?: string;
     enable?: boolean;
@@ -572,23 +573,23 @@ declare const ActiveLearning: sdk.ZodObject<{
     taskId?: string;
     enable?: boolean;
 }>;
-type ZaiConfig = sdk.z.input<typeof ZaiConfig>;
-declare const ZaiConfig: sdk.ZodObject<{
-    client: sdk.Schema<Client, sdk.ZodTypeDef, Client>;
-    userId: sdk.ZodOptional<sdk.ZodString>;
-    retry: sdk.ZodDefault<sdk.ZodObject<{
-        maxRetries: sdk.ZodNumber;
-    }, "strip", sdk.ZodTypeAny, {
+type ZaiConfig = z.input<typeof ZaiConfig>;
+declare const ZaiConfig: _bpinternal_zui.ZodObject<{
+    client: z.Schema<any, _bpinternal_zui.ZodTypeDef, any>;
+    userId: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+    retry: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodObject<{
+        maxRetries: _bpinternal_zui.ZodNumber;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         maxRetries?: number;
     }, {
         maxRetries?: number;
     }>>;
-    modelId: sdk.ZodDefault<sdk.Schema<string, sdk.ZodTypeDef, string>>;
-    activeLearning: sdk.ZodDefault<sdk.ZodObject<{
-        enable: sdk.ZodDefault<sdk.ZodBoolean>;
-        tableName: sdk.ZodDefault<sdk.ZodString>;
-        taskId: sdk.ZodDefault<sdk.ZodString>;
-    }, "strip", sdk.ZodTypeAny, {
+    modelId: _bpinternal_zui.ZodDefault<z.Schema<string, _bpinternal_zui.ZodTypeDef, string>>;
+    activeLearning: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodObject<{
+        enable: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodBoolean>;
+        tableName: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+        taskId: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         tableName?: string;
         taskId?: string;
         enable?: boolean;
@@ -597,9 +598,9 @@ declare const ZaiConfig: sdk.ZodObject<{
         taskId?: string;
         enable?: boolean;
     }>>;
-    namespace: sdk.ZodDefault<sdk.ZodString>;
-}, "strip", sdk.ZodTypeAny, {
-    client?: Client;
+    namespace: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
+    client?: any;
     userId?: string;
     retry?: {
         maxRetries?: number;
@@ -612,7 +613,7 @@ declare const ZaiConfig: sdk.ZodObject<{
     };
     namespace?: string;
 }, {
-    client?: Client;
+    client?: any;
     userId?: string;
     retry?: {
         maxRetries?: number;
@@ -650,10 +651,10 @@ declare class Zai {
     learn(taskId: string): Zai;
 }
 
-type Options$6 = sdk.z.input<typeof Options$6>;
-declare const Options$6: sdk.ZodObject<{
-    length: sdk.ZodOptional<sdk.ZodNumber>;
-}, "strip", sdk.ZodTypeAny, {
+type Options$6 = z.input<typeof Options$6>;
+declare const Options$6: _bpinternal_zui.ZodObject<{
+    length: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodNumber>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     length?: number;
 }, {
     length?: number;
@@ -665,20 +666,20 @@ declare module '@botpress/zai' {
     }
 }
 
-type Options$5 = sdk.z.input<typeof Options$5>;
-declare const Options$5: sdk.ZodObject<{
-    examples: sdk.ZodDefault<sdk.ZodArray<sdk.ZodObject<{
-        input: sdk.ZodString;
-        output: sdk.ZodString;
-    }, "strip", sdk.ZodTypeAny, {
+type Options$5 = z.input<typeof Options$5>;
+declare const Options$5: _bpinternal_zui.ZodObject<{
+    examples: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodArray<_bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodString;
+        output: _bpinternal_zui.ZodString;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: string;
         output?: string;
     }, {
         input?: string;
         output?: string;
     }>, "many">>;
-    length: sdk.ZodOptional<sdk.ZodNumber>;
-}, "strip", sdk.ZodTypeAny, {
+    length: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodNumber>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     length?: number;
     examples?: {
         input?: string;
@@ -698,24 +699,24 @@ declare module '@botpress/zai' {
     }
 }
 
-type Options$4 = sdk.z.input<typeof Options$4>;
-declare const Options$4: sdk.ZodObject<{
-    prompt: sdk.ZodDefault<sdk.ZodString>;
-    format: sdk.ZodDefault<sdk.ZodString>;
-    length: sdk.ZodDefault<sdk.ZodNumber>;
-    intermediateFactor: sdk.ZodDefault<sdk.ZodNumber>;
-    maxIterations: sdk.ZodDefault<sdk.ZodNumber>;
-    sliding: sdk.ZodDefault<sdk.ZodObject<{
-        window: sdk.ZodNumber;
-        overlap: sdk.ZodNumber;
-    }, "strip", sdk.ZodTypeAny, {
+type Options$4 = z.input<typeof Options$4>;
+declare const Options$4: _bpinternal_zui.ZodObject<{
+    prompt: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+    format: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodString>;
+    length: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodNumber>;
+    intermediateFactor: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodNumber>;
+    maxIterations: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodNumber>;
+    sliding: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodObject<{
+        window: _bpinternal_zui.ZodNumber;
+        overlap: _bpinternal_zui.ZodNumber;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         window?: number;
         overlap?: number;
     }, {
         window?: number;
         overlap?: number;
     }>>;
-}, "strip", sdk.ZodTypeAny, {
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     length?: number;
     prompt?: string;
     format?: string;
@@ -743,13 +744,13 @@ declare module '@botpress/zai' {
     }
 }
 
-type Options$3 = sdk.z.input<typeof Options$3>;
-declare const Options$3: sdk.ZodObject<{
-    examples: sdk.ZodDefault<sdk.ZodArray<sdk.ZodObject<{
-        input: sdk.ZodAny;
-        check: sdk.ZodBoolean;
-        reason: sdk.ZodOptional<sdk.ZodString>;
-    }, "strip", sdk.ZodTypeAny, {
+type Options$3 = z.input<typeof Options$3>;
+declare const Options$3: _bpinternal_zui.ZodObject<{
+    examples: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodArray<_bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodAny;
+        check: _bpinternal_zui.ZodBoolean;
+        reason: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: any;
         check?: boolean;
         reason?: string;
@@ -758,7 +759,7 @@ declare const Options$3: sdk.ZodObject<{
         check?: boolean;
         reason?: string;
     }>, "many">>;
-}, "strip", sdk.ZodTypeAny, {
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     examples?: {
         input?: any;
         check?: boolean;
@@ -778,14 +779,14 @@ declare module '@botpress/zai' {
     }
 }
 
-type Options$2 = sdk.z.input<typeof Options$2>;
-declare const Options$2: sdk.ZodObject<{
-    tokensPerItem: sdk.ZodDefault<sdk.ZodOptional<sdk.ZodNumber>>;
-    examples: sdk.ZodDefault<sdk.ZodArray<sdk.ZodObject<{
-        input: sdk.ZodAny;
-        filter: sdk.ZodBoolean;
-        reason: sdk.ZodOptional<sdk.ZodString>;
-    }, "strip", sdk.ZodTypeAny, {
+type Options$2 = z.input<typeof Options$2>;
+declare const Options$2: _bpinternal_zui.ZodObject<{
+    tokensPerItem: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodOptional<_bpinternal_zui.ZodNumber>>;
+    examples: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodArray<_bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodAny;
+        filter: _bpinternal_zui.ZodBoolean;
+        reason: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: any;
         filter?: boolean;
         reason?: string;
@@ -794,7 +795,7 @@ declare const Options$2: sdk.ZodObject<{
         filter?: boolean;
         reason?: string;
     }>, "many">>;
-}, "strip", sdk.ZodTypeAny, {
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     examples?: {
         input?: any;
         filter?: boolean;
@@ -816,11 +817,11 @@ declare module '@botpress/zai' {
     }
 }
 
-type Options$1 = sdk.z.input<typeof Options$1>;
-declare const Options$1: sdk.ZodObject<{
-    instructions: sdk.ZodOptional<sdk.ZodString>;
-    chunkLength: sdk.ZodDefault<sdk.ZodOptional<sdk.ZodNumber>>;
-}, "strip", sdk.ZodTypeAny, {
+type Options$1 = z.input<typeof Options$1>;
+declare const Options$1: _bpinternal_zui.ZodObject<{
+    instructions: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+    chunkLength: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodOptional<_bpinternal_zui.ZodNumber>>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     instructions?: string;
     chunkLength?: number;
 }, {
@@ -830,8 +831,8 @@ declare const Options$1: sdk.ZodObject<{
 declare module '@botpress/zai' {
     interface Zai {
         /** Extracts one or many elements from an arbitrary input */
-        extract<S extends sdk.z.AnyZodObject>(input: unknown, schema: S, options?: Options$1): Promise<sdk.z.infer<S>>;
-        extract<S extends sdk.z.AnyZodObject>(input: unknown, schema: sdk.z.ZodArray<S>, options?: Options$1): Promise<Array<sdk.z.infer<S>>>;
+        extract<S extends z.AnyZodObject>(input: unknown, schema: S, options?: Options$1): Promise<z.infer<S>>;
+        extract<S extends z.AnyZodObject>(input: unknown, schema: z.ZodArray<S>, options?: Options$1): Promise<Array<z.infer<S>>>;
     }
 }
 
@@ -850,23 +851,23 @@ type Example<T extends string> = {
         explanation?: string;
     }>>;
 };
-type Options<T extends string> = Omit<sdk.z.input<typeof Options>, 'examples'> & {
+type Options<T extends string> = Omit<z.input<typeof Options>, 'examples'> & {
     examples?: Array<Partial<Example<T>>>;
 };
-declare const Options: sdk.ZodObject<{
-    examples: sdk.ZodDefault<sdk.ZodArray<sdk.ZodObject<{
-        input: sdk.ZodAny;
-        labels: sdk.ZodRecord<sdk.ZodString, sdk.ZodObject<{
-            label: sdk.ZodEnum<never>;
-            explanation: sdk.ZodOptional<sdk.ZodString>;
-        }, "strip", sdk.ZodTypeAny, {
+declare const Options: _bpinternal_zui.ZodObject<{
+    examples: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodArray<_bpinternal_zui.ZodObject<{
+        input: _bpinternal_zui.ZodAny;
+        labels: _bpinternal_zui.ZodRecord<_bpinternal_zui.ZodString, _bpinternal_zui.ZodObject<{
+            label: _bpinternal_zui.ZodEnum<never>;
+            explanation: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+        }, "strip", _bpinternal_zui.ZodTypeAny, {
             label: never;
             explanation?: string;
         }, {
             label: never;
             explanation?: string;
         }>>;
-    }, "strip", sdk.ZodTypeAny, {
+    }, "strip", _bpinternal_zui.ZodTypeAny, {
         input?: any;
         labels?: Record<string, {
             label: never;
@@ -879,9 +880,9 @@ declare const Options: sdk.ZodObject<{
             explanation?: string;
         }>;
     }>, "many">>;
-    instructions: sdk.ZodOptional<sdk.ZodString>;
-    chunkLength: sdk.ZodDefault<sdk.ZodOptional<sdk.ZodNumber>>;
-}, "strip", sdk.ZodTypeAny, {
+    instructions: _bpinternal_zui.ZodOptional<_bpinternal_zui.ZodString>;
+    chunkLength: _bpinternal_zui.ZodDefault<_bpinternal_zui.ZodOptional<_bpinternal_zui.ZodNumber>>;
+}, "strip", _bpinternal_zui.ZodTypeAny, {
     instructions?: string;
     examples?: {
         input?: any;
@@ -903,7 +904,7 @@ declare const Options: sdk.ZodObject<{
     chunkLength?: number;
 }>;
 type Labels<T extends string> = Record<T, string>;
-declare const Labels: sdk.ZodEffects<sdk.ZodRecord<sdk.ZodString, sdk.ZodString>, Record<string, string>, Record<string, string>>;
+declare const Labels: z.ZodTransformer<_bpinternal_zui.ZodRecord<_bpinternal_zui.ZodString, _bpinternal_zui.ZodString>, Record<string, string>, Record<string, string>>;
 declare module '@botpress/zai' {
     interface Zai {
         /** Tags the provided input with a list of predefined labels */