@botpress/zai 1.0.0-beta.8 → 1.0.1-beta.1

package/scripts/update-types.mts

@@ -0,0 +1,59 @@
+import { Client } from '@botpress/client'
+import sdk from '@botpress/sdk'
+
+import _ from 'lodash'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const { z } = sdk
+
+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 ${sdk.z
+        .fromJsonSchema(input)
+        .title('Input')
+        .dereference(references)
+        .toTypescript({ declaration: 'type' })};
+      export ${sdk.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,214 @@
+import { type Client } from '@botpress/client'
+import sdk from '@botpress/sdk'
+const { z } = sdk
+
+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 = sdk.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: sdk.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 }