@botpress/zai 1.0.0-beta.1 → 1.0.0-beta.3

package/src/scripts/update-models.ts

@@ -1,74 +0,0 @@
-import '../env.ts'
-
-import { Client } from '@botpress/client'
-import { llm } from '@botpress/shared/interfaces'
-import dotenv from 'dotenv'
-import _ from 'lodash'
-import fs from 'node:fs'
-import path from 'node:path'
-
-const envLocal = [
-  path.resolve('.', '.env.local'),
-  path.resolve('../', '.env.local'),
-  path.resolve('../..', '.env.local'),
-  path.resolve('../../..', '.env.local')
-].find(fs.existsSync)
-
-if (envLocal) {
-  dotenv.config({ path: envLocal })
-}
-
-const LLM_LIST_MODELS = 'listLanguageModels' satisfies keyof typeof llm.definition.actions
-
-const client = new Client({
-  apiUrl: process.env.VITE_CLOUD_API_ENDPOINT,
-  botId: process.env.VITE_BOT_ID,
-  token: process.env.VITE_CLOUD_PAT
-})
-
-const { bot } = await client.getBot({
-  id: process.env.VITE_BOT_ID!
-})
-
-type Model = llm.Model & {
-  integration: string
-}
-
-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({
-            ...model,
-            id: `${integration.name}__${model.id}`,
-            integration: integration.name
-          })
-        }
-      }
-    } catch (err) {
-      console.error('Error fetching integration:', err.message)
-    }
-  }
-}
-
-const content = JSON.stringify(_.orderBy(models, ['integration', 'name']), null, 2)
-
-fs.writeFileSync('./src/models.ts', `export const Models = ${content} as const`, 'utf-8')

package/src/utils.ts

@@ -1,61 +0,0 @@
-import { Client } from '@botpress/client'
-import { z } from '@bpinternal/zui'
-
-export const stringify = (input: unknown, beautify = true) => {
-  return typeof input === 'string' && !!input.length
-    ? input
-    : input
-      ? JSON.stringify(input, beautify ? null : undefined, beautify ? 2 : undefined)
-      : '<input is null, false, undefined or empty>'
-}
-
-export const BotpressClient = z.custom<Client>(
-  (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'
-  }
-)
-
-export function fastHash(str: string): string {
-  let hash = 0
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) - hash + str.charCodeAt(i)
-    hash |= 0 // Convert to 32bit integer
-  }
-  return (hash >>> 0).toString(16) // Convert to unsigned and then to hex
-}
-
-export const takeUntilTokens = <T>(arr: T[], tokens: number, count: (el: T) => number) => {
-  const result: T[] = []
-  let total = 0
-
-  for (const value of arr) {
-    const valueTokens = count(value)
-    if (total + valueTokens > tokens) {
-      break
-    }
-    total += valueTokens
-    result.push(value)
-  }
-
-  return result
-}
-
-export type GenerationMetadata = z.input<typeof GenerationMetadata>
-export const 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')
-})

package/src/zai.ts

@@ -1,179 +0,0 @@
-import { Client } from '@botpress/client'
-import { llm } from '@botpress/shared/interfaces'
-import { type TextTokenizer, getWasmTokenizer } from '@botpress/wasm'
-import { z } from '@bpinternal/zui'
-
-import { Adapter } from './adapters/adapter'
-import { TableAdapter } from './adapters/botpress-table'
-import { MemoryAdapter } from './adapters/memory'
-import { Models } from './models'
-import { BotpressClient, GenerationMetadata } from './utils'
-
-type ModelId = (typeof Models)[number]['id']
-
-type ActiveLearning = z.input<typeof ActiveLearning>
-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')
-})
-
-type ZaiConfig = z.input<typeof ZaiConfig>
-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<ModelId>(
-      (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' satisfies ModelId),
-  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 {
-  protected static tokenizer: TextTokenizer = null!
-  protected client: Client
-
-  private originalConfig: ZaiConfig
-
-  private userId: string | undefined
-  private integration: string
-  private model: string
-  private retry: { maxRetries: number }
-
-  protected Model: (typeof Models)[number]
-  protected namespace: string
-  protected adapter: Adapter
-  protected activeLearning: ActiveLearning
-
-  constructor(config: ZaiConfig) {
-    this.originalConfig = config
-    const parsed = ZaiConfig.parse(config)
-
-    this.client = parsed.client
-    const [integration, modelId] = parsed.modelId.split('__')
-    this.integration = integration
-    this.model = modelId
-    this.namespace = parsed.namespace
-    this.userId = parsed.userId
-    this.retry = parsed.retry as typeof this.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([])
-  }
-
-  protected async callModel(
-    props: Partial<llm.GenerateContentInput>
-  ): Promise<llm.GenerateContentOutput & { metadata: GenerationMetadata }> {
-    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, 1000))
-        } else {
-          throw new Error('Failed to call model after multiple retries', e)
-        }
-      }
-    }
-
-    throw new Error('Failed to call model after multiple retries')
-  }
-
-  private async _callModel(
-    props: Partial<llm.GenerateContentInput>
-  ): Promise<llm.GenerateContentOutput & { metadata: GenerationMetadata }> {
-    let retries = this.retry.maxRetries
-    do {
-      const start = Date.now()
-      const input: llm.GenerateContentInput = {
-        messages: [],
-        temperature: 0.0,
-        topP: 1,
-        model: { id: this.model },
-        userId: this.userId,
-        ...props
-      }
-
-      const { output } = (await this.client.callAction({
-        type: `${this.integration}:generateContent`,
-        input
-      })) as unknown as { output: llm.GenerateContentOutput }
-
-      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)
-  }
-
-  protected async getTokenizer() {
-    Zai.tokenizer ??= await getWasmTokenizer()
-    return Zai.tokenizer
-  }
-
-  protected get taskId() {
-    if (!this.activeLearning.enable) {
-      return undefined
-    }
-
-    return `${this.namespace}/${this.activeLearning.taskId}`.replace(/\/+/g, '/')
-  }
-
-  public with(options: Partial<ZaiConfig>): Zai {
-    return new Zai({
-      ...this.originalConfig,
-      ...options
-    })
-  }
-
-  public learn(taskId: string) {
-    return new Zai({
-      ...this.originalConfig,
-      activeLearning: { ...this.activeLearning, taskId, enable: true }
-    })
-  }
-}