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

package/src/adapters/adapter.ts

@@ -1,35 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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

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

package/src/env.ts

@@ -1,54 +0,0 @@
-import { z } from '@bpinternal/zui'
-import dotenv from 'dotenv'
-
-dotenv.config({ override: false })
-dotenv.populate(
-  process.env,
-  {
-    VITE_CLOUD_API_ENDPOINT: 'https://api.botpress.dev'
-  },
-  { override: false }
-)
-
-const envVariables = z.object({
-  CI: z.coerce.boolean().optional().describe('Indicates whether the tests are running in a CI environment'),
-  VITE_CLOUD_API_ENDPOINT: z.string(),
-  VITE_BOT_ID: z.string(),
-  VITE_CLOUD_PAT: z.string(),
-  // for CI
-  VITEST_CLOUD_PAT: z.string().optional(),
-  VITEST_BOT_ID: z.string().optional()
-})
-
-const result = envVariables.safeParse(process.env)
-
-if (!result.success) {
-  for (const error of result.error.errors) {
-    if (error.code === 'invalid_type') {
-      console.error(`Missing environment variable: ${error.path.join('.')}`)
-    } else {
-      console.error(error)
-    }
-  }
-}
-
-type Deprecated = Omit<
-  {
-    [key: string]: any
-  },
-  keyof z.infer<typeof envVariables>
->
-
-type AllEnv = z.infer<typeof envVariables> & Deprecated
-
-/** @internal */
-declare global {
-  namespace NodeJS {
-    interface ProcessEnv extends AllEnv {
-      /**  @deprecated please define your ENV variable in {@link env.ts} */
-      [key: keyof Deprecated]: any
-    }
-  }
-}
-
-export {}

package/src/index.ts

@@ -1,11 +0,0 @@
-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 }

package/src/models.ts

@@ -1,347 +0,0 @@
-export const Models = [
-  {
-    "id": "anthropic__claude-3-haiku-20240307",
-    "name": "Claude 3 Haiku",
-    "description": "Claude 3 Haiku is Anthropic's fastest and most compact model for near-instant responsiveness. Quick and accurate targeted performance.",
-    "tags": [
-      "low-cost",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.25,
-      "maxTokens": 200000
-    },
-    "output": {
-      "costPer1MTokens": 1.25,
-      "maxTokens": 4096
-    },
-    "integration": "anthropic"
-  },
-  {
-    "id": "anthropic__claude-3-5-sonnet-20240620",
-    "name": "Claude 3.5 Sonnet",
-    "description": "Claude 3.5 Sonnet delivers better-than-Opus capabilities, faster-than-Sonnet speeds, at the same Sonnet prices. Sonnet is particularly good at coding, data science, visual processing, and agentic tasks.",
-    "tags": [
-      "recommended",
-      "vision",
-      "general-purpose",
-      "agents",
-      "coding",
-      "function-calling",
-      "storytelling"
-    ],
-    "input": {
-      "costPer1MTokens": 3,
-      "maxTokens": 200000
-    },
-    "output": {
-      "costPer1MTokens": 15,
-      "maxTokens": 4096
-    },
-    "integration": "anthropic"
-  },
-  {
-    "id": "groq__gemma-7b-it",
-    "name": "Gemma 7B",
-    "description": "Gemma is a family of lightweight, state-of-the-art open models from Google, built from the same research and technology used to create the Gemini models. They are text-to-text, decoder-only large language models, available in English, with open weights, pre-trained variants, and instruction-tuned variants. Gemma models are well-suited for a variety of text generation tasks, including question answering, summarization, and reasoning.",
-    "tags": [
-      "deprecated",
-      "low-cost"
-    ],
-    "input": {
-      "costPer1MTokens": 0.07,
-      "maxTokens": 8192
-    },
-    "output": {
-      "costPer1MTokens": 0.07,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__gemma2-9b-it",
-    "name": "Gemma2 9B",
-    "description": "Redesigned for outsized performance and unmatched efficiency, Gemma 2 optimizes for blazing-fast inference on diverse hardware. Gemma is a family of lightweight, state-of-the-art open models from Google, built from the same research and technology used to create the Gemini models. They are text-to-text, decoder-only large language models, available in English, with open weights, pre-trained variants, and instruction-tuned variants. Gemma models are well-suited for a variety of text generation tasks, including question answering, summarization, and reasoning.",
-    "tags": [
-      "low-cost",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.2,
-      "maxTokens": 8192
-    },
-    "output": {
-      "costPer1MTokens": 0.2,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama3-70b-8192",
-    "name": "LLaMA 3 70B",
-    "tags": [
-      "general-purpose"
-    ],
-    "description": "Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrained and instruction tuned generative text models in 8 and 70B sizes. The Llama 3 instruction tuned models are optimized for dialogue use cases and outperform many of the available open source chat models on common industry benchmarks.",
-    "input": {
-      "costPer1MTokens": 0.59,
-      "maxTokens": 8192
-    },
-    "output": {
-      "costPer1MTokens": 0.79,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama3-8b-8192",
-    "name": "LLaMA 3 8B",
-    "description": "Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrained and instruction tuned generative text models in 8 and 70B sizes. The Llama 3 instruction tuned models are optimized for dialogue use cases and outperform many of the available open source chat models on common industry benchmarks.",
-    "tags": [
-      "low-cost",
-      "general-purpose",
-      "deprecated"
-    ],
-    "input": {
-      "costPer1MTokens": 0.05,
-      "maxTokens": 8192
-    },
-    "output": {
-      "costPer1MTokens": 0.08,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.1-70b-versatile",
-    "name": "LLaMA 3.1 70B",
-    "description": "The Llama 3.1 instruction-tuned, text-only models are optimized for multilingual dialogue use cases.",
-    "tags": [
-      "recommended",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.59,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.79,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.1-8b-instant",
-    "name": "LLaMA 3.1 8B",
-    "description": "The Llama 3.1 instruction-tuned, text-only models are optimized for multilingual dialogue use cases.",
-    "tags": [
-      "low-cost",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.05,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.08,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.2-11b-vision-preview",
-    "name": "LLaMA 3.2 11B Vision (Preview)",
-    "description": "[BETA preview version] The Llama 3.2-Vision instruction-tuned models are optimized for visual recognition, image reasoning, captioning, and answering general questions about an image.",
-    "tags": [
-      "low-cost",
-      "vision",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.18,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.18,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.2-1b-preview",
-    "name": "LLaMA 3.2 1B (Preview)",
-    "description": "[BETA preview version] The Llama 3.2 instruction-tuned, text-only models are optimized for multilingual dialogue use cases, including agentic retrieval and summarization tasks.",
-    "tags": [
-      "low-cost"
-    ],
-    "input": {
-      "costPer1MTokens": 0.04,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.04,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.2-3b-preview",
-    "name": "LLaMA 3.2 3B (Preview)",
-    "description": "[BETA preview version] The Llama 3.2 instruction-tuned, text-only models are optimized for multilingual dialogue use cases, including agentic retrieval and summarization tasks.",
-    "tags": [
-      "low-cost",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.06,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.06,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__llama-3.2-90b-vision-preview",
-    "name": "LLaMA 3.2 90B Vision (Preview)",
-    "description": "[BETA preview version] The Llama 3.2-Vision instruction-tuned models are optimized for visual recognition, image reasoning, captioning, and answering general questions about an image.",
-    "tags": [
-      "recommended",
-      "vision",
-      "general-purpose"
-    ],
-    "input": {
-      "costPer1MTokens": 0.9,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.9,
-      "maxTokens": 8192
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "groq__mixtral-8x7b-32768",
-    "name": "Mixtral 8x7B",
-    "tags": [
-      "low-cost",
-      "general-purpose",
-      "deprecated"
-    ],
-    "description": "Mistral MoE 8x7B Instruct v0.1 model with Sparse Mixture of Experts. Fine tuned for instruction following",
-    "input": {
-      "costPer1MTokens": 0.24,
-      "maxTokens": 32768
-    },
-    "output": {
-      "costPer1MTokens": 0.24,
-      "maxTokens": 32768
-    },
-    "integration": "groq"
-  },
-  {
-    "id": "openai__gpt-3.5-turbo-0125",
-    "name": "GPT-3.5 Turbo",
-    "description": "GPT-3.5 Turbo can understand and generate natural language or code and has been optimized for chat but works well for non-chat tasks as well.",
-    "tags": [
-      "deprecated",
-      "general-purpose",
-      "low-cost"
-    ],
-    "input": {
-      "costPer1MTokens": 0.5,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 1.5,
-      "maxTokens": 4096
-    },
-    "integration": "openai"
-  },
-  {
-    "id": "openai__gpt-4-turbo-2024-04-09",
-    "name": "GPT-4 Turbo",
-    "description": "GPT-4 is a large multimodal model (accepting text or image inputs and outputting text) that can solve difficult problems with greater accuracy than any of our previous models, thanks to its broader general knowledge and advanced reasoning capabilities.",
-    "tags": [
-      "deprecated",
-      "general-purpose",
-      "coding",
-      "agents",
-      "function-calling"
-    ],
-    "input": {
-      "costPer1MTokens": 10,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 30,
-      "maxTokens": 4096
-    },
-    "integration": "openai"
-  },
-  {
-    "id": "openai__gpt-4o-2024-08-06",
-    "name": "GPT-4o (August 2024)",
-    "description": "GPT-4o (“o” for “omni”) is OpenAI's most advanced model. It is multimodal (accepting text or image inputs and outputting text), and it has the same high intelligence as GPT-4 Turbo but is cheaper and more efficient.",
-    "tags": [
-      "recommended",
-      "vision",
-      "general-purpose",
-      "coding",
-      "agents",
-      "function-calling"
-    ],
-    "input": {
-      "costPer1MTokens": 2.5,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 10,
-      "maxTokens": 16384
-    },
-    "integration": "openai"
-  },
-  {
-    "id": "openai__gpt-4o-2024-05-13",
-    "name": "GPT-4o (May 2024)",
-    "description": "GPT-4o (“o” for “omni”) is OpenAI's most advanced model. It is multimodal (accepting text or image inputs and outputting text), and it has the same high intelligence as GPT-4 Turbo but is cheaper and more efficient.",
-    "tags": [
-      "vision",
-      "general-purpose",
-      "coding",
-      "agents",
-      "function-calling"
-    ],
-    "input": {
-      "costPer1MTokens": 5,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 15,
-      "maxTokens": 4096
-    },
-    "integration": "openai"
-  },
-  {
-    "id": "openai__gpt-4o-mini-2024-07-18",
-    "name": "GPT-4o Mini",
-    "description": "GPT-4o mini (“o” for “omni”) is OpenAI's most advanced model in the small models category, and their cheapest model yet. It is multimodal (accepting text or image inputs and outputting text), has higher intelligence than gpt-3.5-turbo but is just as fast. It is meant to be used for smaller tasks, including vision tasks. It's recommended to choose gpt-4o-mini where you would have previously used gpt-3.5-turbo as this model is more capable and cheaper.",
-    "tags": [
-      "recommended",
-      "vision",
-      "low-cost",
-      "general-purpose",
-      "function-calling"
-    ],
-    "input": {
-      "costPer1MTokens": 0.15,
-      "maxTokens": 128000
-    },
-    "output": {
-      "costPer1MTokens": 0.6,
-      "maxTokens": 16384
-    },
-    "integration": "openai"
-  }
-] as const