@botpress/zai 1.0.0-beta.9 → 1.0.1-beta.2

package/dist/node/zai.js

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

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "@botpress/zai",
-  "version": "1.0.0-beta.9",
-  "type": "module",
-  "private": false,
   "description": "Zui AI (zai) – An LLM utility library written on top of Zui and the Botpress API",
+  "version": "1.0.1-beta.2",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "types": "./src/index.ts",
+      "node": "./dist/node/index.js",
+      "default": "./dist/node/index.js"
+    },
+    "./browser": {
+      "types": "./src/index.ts",
+      "browser": "./dist/browser/index.js"
     }
   },
+  "main": "./dist/node/index.js",
+  "browser": "./dist/browser/index.js",
+  "types": "./src/index.ts",
   "scripts": {
-    "build": "tsup",
+    "build": "npm run build:nodejs && npm run build:browser",
+    "build:nodejs": "esbuild src/**/*.ts src/*.ts --platform=node --target=node16 --outdir=dist/node",
+    "build:browser": "esbuild src/index.ts --bundle --external:@bpinternal/zui --external:@botpress/client --external:@botpress/wasm --platform=browser --target=chrome58,firefox57,safari11 --outdir=dist/browser",
     "watch": "tsup --watch",
     "test": "vitest run --config vitest.config.ts",
     "test:update": "vitest -u run --config vitest.config.ts",
     "test:watch": "vitest --config vitest.config.ts",
     "build-with-latest-models": "pnpm run update-types && pnpm run update-models && pnpm run build",
-    "update-models": "ts-node ./src/scripts/update-models.ts",
-    "update-types": "ts-node ./src/scripts/update-types.ts"
+    "update-models": "ts-node ./scripts/update-models.mts",
+    "update-types": "ts-node ./scripts/update-types.mts"
   },
   "keywords": [],
   "author": "",
@@ -27,20 +34,21 @@
   "dependencies": {
     "json5": "^2.2.1",
     "jsonrepair": "^3.2.0",
-    "lodash": "^4.17.21"
+    "lodash-es": "^4.17.21"
   },
   "devDependencies": {
     "@botpress/vai": "0.0.1-beta.7",
-    "@types/lodash": "^4.17.0",
+    "@types/lodash-es": "^4.17.0",
     "dotenv": "^16.3.1",
+    "esbuild": "^0.24.2",
     "ts-node": "^10.9.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.0.5"
   },
   "peerDependencies": {
-    "@botpress/client": "^0.36.2",
-    "@botpress/sdk": "^1.6.1",
+    "@botpress/client": "^0.40.0",
+    "@bpinternal/zui": "^0.13.3",
     "@botpress/wasm": "^1.0.0"
   }
 }

package/scripts/update-models.mts

@@ -0,0 +1,76 @@
+import { Client } from '@botpress/client'
+
+import { orderBy, isArray } from 'lodash-es'
+import fs from 'node:fs'
+
+const LLM_LIST_MODELS = 'listLanguageModels'
+
+const client = new Client({
+  apiUrl: process.env.CLOUD_API_ENDPOINT,
+  botId: process.env.CLOUD_BOT_ID,
+  token: process.env.CLOUD_PAT
+})
+
+const { bot } = await client.getBot({
+  id: process.env.CLOUD_BOT_ID!
+})
+
+type Model = {
+  id: string
+  name: string
+  integration: string
+  input: { maxTokens: number }
+  output: { maxTokens: number }
+}
+
+const models: Model[] = []
+
+for (const integrationId in bot.integrations) {
+  const botIntegration = bot.integrations[integrationId]
+  if (botIntegration?.public && botIntegration?.enabled && botIntegration?.status === 'registered') {
+    try {
+      const { integration } = await client.getPublicIntegrationById({
+        id: botIntegration.id
+      })
+
+      const canListModels = Object.keys(integration.actions).includes(LLM_LIST_MODELS)
+      if (!canListModels) {
+        continue
+      }
+
+      const { output } = await client.callAction({
+        type: `${integration.name}:${LLM_LIST_MODELS}`,
+        input: {}
+      })
+
+      if (isArray(output?.models)) {
+        for (const model of output.models) {
+          models.push({
+            id: `${integration.name}__${model.id}`,
+            name: model.name,
+            integration: integration.name,
+            input: { maxTokens: model.input.maxTokens },
+            output: { maxTokens: model.output.maxTokens }
+          })
+        }
+      }
+    } catch (err: unknown) {
+      console.error('Error fetching integration:', err instanceof Error ? err.message : `${err}`)
+    }
+  }
+}
+
+const content = JSON.stringify(orderBy(models, ['integration', 'name']), null, 2)
+
+fs.writeFileSync(
+  './src/models.ts',
+  `
+// This file is generated. Do not edit it manually.
+// See 'scripts/update-models.ts'
+
+/* eslint-disable */
+/* tslint:disable */
+
+export const Models = ${content} as const`,
+  'utf-8'
+)

package/scripts/update-types.mts

@@ -0,0 +1,49 @@
+import { Client } from '@botpress/client'
+import { z } from '@bpinternal/zui'
+
+import { maxBy } from 'lodash-es'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const Interfaces = ['llm'] as const
+
+const client = new Client({
+  apiUrl: process.env.CLOUD_API_ENDPOINT,
+  botId: process.env.CLOUD_BOT_ID,
+  token: process.env.CLOUD_PAT
+})
+
+for (const name of Interfaces) {
+  const { interfaces } = await client.listInterfaces({
+    name
+  })
+
+  const { interface: latest } = await client.getInterface({
+    id: maxBy(interfaces, 'version')!.id
+  })
+
+  for (const action of Object.keys(latest.actions)) {
+    const references = Object.keys(latest.entities).reduce((acc, key) => {
+      return { ...acc, [key]: z.fromJsonSchema(latest.entities?.[key]?.schema!) }
+    }, {})
+    const input = latest.actions[action]?.input.schema!
+    const output = latest.actions[action]?.output.schema!
+
+    const types = `
+// This file is generated. Do not edit it manually.
+// See 'scripts/update-models.ts'
+
+/* eslint-disable */
+/* tslint:disable */
+
+export namespace ${name} {
+    export namespace ${action} {
+      export ${z.fromJsonSchema(input).title('Input').dereference(references).toTypescript({ declaration: 'type' })};
+      export ${z.fromJsonSchema(output).title('Output').dereference(references).toTypescript({ declaration: 'type' })};
+    }
+}`
+
+    fs.mkdirSync(path.resolve(`./src/sdk-interfaces/${name}`), { recursive: true })
+    fs.writeFileSync(path.resolve(`./src/sdk-interfaces/${name}/${action}.ts`), types)
+  }
+}

package/src/adapters/adapter.ts

@@ -0,0 +1,35 @@
+import { GenerationMetadata } from '../utils'
+
+export type SaveExampleProps<TInput, TOutput> = {
+  key: string
+  taskType: string
+  taskId: string
+  instructions: string
+  input: TInput
+  output: TOutput
+  explanation?: string
+  metadata: GenerationMetadata
+  status?: 'pending' | 'approved'
+}
+
+export type GetExamplesProps<TInput> = {
+  taskType: string
+  taskId: string
+  input: TInput
+}
+
+export abstract class Adapter {
+  abstract getExamples<TInput, TOutput>(
+    props: GetExamplesProps<TInput>
+  ): Promise<
+    Array<{
+      key: string
+      input: TInput
+      output: TOutput
+      explanation?: string
+      similarity: number
+    }>
+  >
+
+  abstract saveExample<TInput, TOutput>(props: SaveExampleProps<TInput, TOutput>): Promise<void>
+}

package/src/adapters/botpress-table.ts

@@ -0,0 +1,213 @@
+import { type Client } from '@botpress/client'
+import { z } from '@bpinternal/zui'
+
+import { BotpressClient, GenerationMetadata } from '../utils'
+import { Adapter, GetExamplesProps, SaveExampleProps } from './adapter'
+
+const CRITICAL_TAGS = {
+  system: 'true',
+  'schema-purpose': 'active-learning',
+  'schema-version': 'Oct-2024'
+} as const
+
+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'
+} as const
+
+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'
+    )
+})
+
+export type TableSchema = z.input<typeof TableSchema>
+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'] as const satisfies Array<keyof typeof TableSchema.shape> as string[]
+
+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 {
+  private client: Client
+  private tableName: string
+
+  private status: 'initialized' | 'ready' | 'error'
+  private errors = [] as string[]
+
+  constructor(props: z.input<typeof Props>) {
+    super()
+    props = Props.parse(props)
+    this.client = props.client
+    this.tableName = props.tableName
+    this.status = 'ready'
+  }
+
+  public async getExamples<TInput, TOutput>({ taskType, taskId, input }: GetExamplesProps<TInput>) {
+    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'
+        } satisfies Partial<TableSchema>
+      })
+      .catch((err) => {
+        // TODO: handle error
+        console.error(`Error fetching examples: ${err.message}`)
+        return { rows: [] }
+      })
+
+    return rows.map((row) => ({
+      key: row.key,
+      input: row.input.value as TInput,
+      output: row.output.value as TOutput,
+      explanation: row.explanation,
+      similarity: row.similarity ?? 0
+    }))
+  }
+
+  public async saveExample<TInput, TOutput>({
+    key,
+    taskType,
+    taskId,
+    instructions,
+    input,
+    output,
+    explanation,
+    metadata,
+    status = 'pending'
+  }: SaveExampleProps<TInput, TOutput>) {
+    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
+          } satisfies TableSchema
+        ]
+      })
+      .catch(() => {
+        // TODO: handle error
+      })
+  }
+
+  private 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: string[] = []
+
+      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] as { type: string }
+
+        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'
+  }
+}

package/src/adapters/memory.ts

@@ -0,0 +1,13 @@
+import { Adapter } from './adapter'
+
+export class MemoryAdapter extends Adapter {
+  constructor(public examples: any[]) {
+    super()
+  }
+
+  async getExamples() {
+    return this.examples
+  }
+
+  async saveExample() {}
+}

package/src/index.ts

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