@botpress/zai 1.0.1-beta.3 → 1.0.1-beta.5

package/src/sdk-interfaces/llm/generateContent.d.ts

@@ -0,0 +1,128 @@
+export declare namespace llm {
+    namespace generateContent {
+        type Input = {
+            /** Model to use for content generation */
+            model?: {
+                id: string;
+            };
+            /** Optional system prompt to guide the model */
+            systemPrompt?: string;
+            /** Array of messages for the model to process */
+            messages: Array<{
+                role: 'user' | 'assistant';
+                type?: 'text' | 'tool_calls' | 'tool_result' | 'multipart';
+                /** Required if `type` is "tool_calls" */
+                toolCalls?: Array<{
+                    id: string;
+                    type: 'function';
+                    function: {
+                        name: string;
+                        /** Some LLMs may generate invalid JSON for a tool call, so this will be `null` when it happens. */
+                        arguments: {
+                            [key: string]: any;
+                        } | null;
+                    };
+                }>;
+                /** Required if `type` is "tool_result" */
+                toolResultCallId?: string;
+                /** Required unless `type` is "tool_call". If `type` is "multipart", this field must be an array of content objects. If `type` is "tool_result" then this field should be the result of the tool call (a plain string or a JSON-encoded array or object). If `type` is "tool_call" then the `toolCalls` field should be used instead. */
+                content: string | Array<{
+                    type: 'text' | 'image';
+                    /** Indicates the MIME type of the content. If not provided it will be detected from the content-type header of the provided URL. */
+                    mimeType?: string;
+                    /** Required if part type is "text" */
+                    text?: string;
+                    /** Required if part type is "image" */
+                    url?: string;
+                }> | null;
+            }>;
+            /** Response format expected from the model. If "json_object" is chosen, you must instruct the model to generate JSON either via the system prompt or a user message. */
+            responseFormat?: 'text' | 'json_object';
+            /** Maximum number of tokens allowed in the generated response */
+            maxTokens?: number;
+            /** Sampling temperature for the model. Higher values result in more random outputs. */
+            temperature?: number;
+            /** Top-p sampling parameter. Limits sampling to the smallest set of tokens with a cumulative probability above the threshold. */
+            topP?: number;
+            /** Sequences where the model should stop generating further tokens. */
+            stopSequences?: string[];
+            tools?: Array<{
+                type: 'function';
+                function: {
+                    /** Function name */
+                    name: string;
+                    description?: string;
+                    /** JSON schema of the function arguments */
+                    argumentsSchema?: {};
+                };
+            }>;
+            toolChoice?: {
+                type?: 'auto' | 'specific' | 'any' | 'none' | '';
+                /** Required if `type` is "specific" */
+                functionName?: string;
+            };
+            userId?: string;
+            /** Set to `true` to output debug information to the bot logs */
+            debug?: boolean;
+            meta?: {
+                /** Source of the prompt, e.g. agent/:id/:version cards/ai-generate, cards/ai-task, nodes/autonomous, etc. */
+                promptSource?: string;
+                promptCategory?: string;
+                /** Name of the integration that originally received the message that initiated this action */
+                integrationName?: string;
+            };
+        };
+        type Output = {
+            /** Response ID from LLM provider */
+            id: string;
+            /** LLM provider name */
+            provider: string;
+            /** Model name */
+            model: string;
+            choices: Array<{
+                type?: 'text' | 'tool_calls' | 'tool_result' | 'multipart';
+                /** Required if `type` is "tool_calls" */
+                toolCalls?: Array<{
+                    id: string;
+                    type: 'function';
+                    function: {
+                        name: string;
+                        /** Some LLMs may generate invalid JSON for a tool call, so this will be `null` when it happens. */
+                        arguments: {
+                            [key: string]: any;
+                        } | null;
+                    };
+                }>;
+                /** Required if `type` is "tool_result" */
+                toolResultCallId?: string;
+                /** Required unless `type` is "tool_call". If `type` is "multipart", this field must be an array of content objects. If `type` is "tool_result" then this field should be the result of the tool call (a plain string or a JSON-encoded array or object). If `type` is "tool_call" then the `toolCalls` field should be used instead. */
+                content: string | Array<{
+                    type: 'text' | 'image';
+                    /** Indicates the MIME type of the content. If not provided it will be detected from the content-type header of the provided URL. */
+                    mimeType?: string;
+                    /** Required if part type is "text" */
+                    text?: string;
+                    /** Required if part type is "image" */
+                    url?: string;
+                }> | null;
+                role: 'assistant';
+                index: number;
+                stopReason: 'stop' | 'max_tokens' | 'tool_calls' | 'content_filter' | 'other';
+            }>;
+            usage: {
+                /** Number of input tokens used by the model */
+                inputTokens: number;
+                /** Cost of the input tokens received by the model, in U.S. dollars */
+                inputCost: number;
+                /** Number of output tokens used by the model */
+                outputTokens: number;
+                /** Cost of the output tokens generated by the model, in U.S. dollars */
+                outputCost: number;
+            };
+            botpress: {
+                /** Total cost of the content generation, in U.S. dollars */
+                cost: number;
+            };
+        };
+    }
+}

package/src/sdk-interfaces/llm/listLanguageModels.d.ts

@@ -0,0 +1,25 @@
+export declare namespace llm {
+    namespace listLanguageModels {
+        type Input = {};
+        type Output = {
+            models: Array<{
+                id: string;
+                name: string;
+                description: string;
+                tags: Array<'recommended' | 'deprecated' | 'general-purpose' | 'low-cost' | 'vision' | 'coding' | 'agents' | 'function-calling' | 'roleplay' | 'storytelling' | 'reasoning'>;
+                input: {
+                    maxTokens: number;
+                    /** Cost per 1 million tokens, in U.S. dollars */
+                    costPer1MTokens: number;
+                };
+                output: {
+                    maxTokens: number;
+                    /** Cost per 1 million tokens, in U.S. dollars */
+                    costPer1MTokens: number;
+                };
+            } & {
+                id: string;
+            }>;
+        };
+    }
+}

package/src/utils.d.ts

@@ -0,0 +1,52 @@
+import { z } from '@bpinternal/zui';
+export declare const stringify: (input: unknown, beautify?: boolean) => string;
+export declare const BotpressClient: z.Schema<any, import("@bpinternal/zui").ZodTypeDef, any>;
+export declare function fastHash(str: string): string;
+export declare const takeUntilTokens: <T>(arr: T[], tokens: number, count: (el: T) => number) => T[];
+export type GenerationMetadata = z.input<typeof GenerationMetadata>;
+export declare const GenerationMetadata: import("@bpinternal/zui").ZodObject<{
+    model: import("@bpinternal/zui").ZodString;
+    cost: import("@bpinternal/zui").ZodObject<{
+        input: import("@bpinternal/zui").ZodNumber;
+        output: import("@bpinternal/zui").ZodNumber;
+    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
+        input?: number;
+        output?: number;
+    }, {
+        input?: number;
+        output?: number;
+    }>;
+    latency: import("@bpinternal/zui").ZodNumber;
+    tokens: import("@bpinternal/zui").ZodObject<{
+        input: import("@bpinternal/zui").ZodNumber;
+        output: import("@bpinternal/zui").ZodNumber;
+    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
+        input?: number;
+        output?: number;
+    }, {
+        input?: number;
+        output?: number;
+    }>;
+}, "strip", import("@bpinternal/zui").ZodTypeAny, {
+    model?: string;
+    cost?: {
+        input?: number;
+        output?: number;
+    };
+    latency?: number;
+    tokens?: {
+        input?: number;
+        output?: number;
+    };
+}, {
+    model?: string;
+    cost?: {
+        input?: number;
+        output?: number;
+    };
+    latency?: number;
+    tokens?: {
+        input?: number;
+        output?: number;
+    };
+}>;

package/src/utils.ts

@@ -42,7 +42,7 @@ export const takeUntilTokens = <T>(arr: T[], tokens: number, count: (el: T) => n
   return result
 }
 
-export type GenerationMetadata = sdk.z.input<typeof GenerationMetadata>
+export type GenerationMetadata = z.input<typeof GenerationMetadata>
 export const GenerationMetadata = z.object({
   model: z.string(),
   cost: z

package/src/zai.d.ts

@@ -0,0 +1,99 @@
+import { Client } from '@botpress/client';
+import { z } from '@bpinternal/zui';
+import { type TextTokenizer } from '@botpress/wasm';
+import { Adapter } from './adapters/adapter';
+import { Models } from './models';
+import { llm } from './sdk-interfaces/llm/generateContent';
+import { GenerationMetadata } from './utils';
+type ActiveLearning = z.input<typeof ActiveLearning>;
+declare const ActiveLearning: import("@bpinternal/zui").ZodObject<{
+    enable: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodBoolean>;
+    tableName: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodString>;
+    taskId: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodString>;
+}, "strip", import("@bpinternal/zui").ZodTypeAny, {
+    tableName?: string;
+    taskId?: string;
+    enable?: boolean;
+}, {
+    tableName?: string;
+    taskId?: string;
+    enable?: boolean;
+}>;
+type ZaiConfig = z.input<typeof ZaiConfig>;
+declare const ZaiConfig: import("@bpinternal/zui").ZodObject<{
+    client: z.Schema<any, import("@bpinternal/zui").ZodTypeDef, any>;
+    userId: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+    retry: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodObject<{
+        maxRetries: import("@bpinternal/zui").ZodNumber;
+    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
+        maxRetries?: number;
+    }, {
+        maxRetries?: number;
+    }>>;
+    modelId: import("@bpinternal/zui").ZodDefault<z.Schema<string, import("@bpinternal/zui").ZodTypeDef, string>>;
+    activeLearning: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodObject<{
+        enable: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodBoolean>;
+        tableName: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodString>;
+        taskId: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodString>;
+    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
+        tableName?: string;
+        taskId?: string;
+        enable?: boolean;
+    }, {
+        tableName?: string;
+        taskId?: string;
+        enable?: boolean;
+    }>>;
+    namespace: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodString>;
+}, "strip", import("@bpinternal/zui").ZodTypeAny, {
+    client?: any;
+    userId?: string;
+    retry?: {
+        maxRetries?: number;
+    };
+    modelId?: string;
+    activeLearning?: {
+        tableName?: string;
+        taskId?: string;
+        enable?: boolean;
+    };
+    namespace?: string;
+}, {
+    client?: any;
+    userId?: string;
+    retry?: {
+        maxRetries?: number;
+    };
+    modelId?: string;
+    activeLearning?: {
+        tableName?: string;
+        taskId?: string;
+        enable?: boolean;
+    };
+    namespace?: string;
+}>;
+export declare class Zai {
+    protected static tokenizer: TextTokenizer;
+    protected client: Client;
+    private originalConfig;
+    private userId;
+    private integration;
+    private model;
+    private retry;
+    protected Model: (typeof Models)[number];
+    protected namespace: string;
+    protected adapter: Adapter;
+    protected activeLearning: ActiveLearning;
+    constructor(config: ZaiConfig);
+    /** @internal */
+    protected callModel(props: Partial<llm.generateContent.Input>): Promise<llm.generateContent.Output & {
+        metadata: GenerationMetadata;
+    }>;
+    /** @internal */
+    private _callModel;
+    protected getTokenizer(): Promise<TextTokenizer>;
+    protected get taskId(): string;
+    with(options: Partial<ZaiConfig>): Zai;
+    learn(taskId: string): Zai;
+}
+export {};

package/tsconfig.json

@@ -3,6 +3,7 @@
     "target": "ESNext",
     "module": "ESNext",
     "moduleResolution": "bundler",
+    "outDir": "dist",
     "allowJs": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
@@ -16,7 +17,7 @@
     "noUnusedParameters": true,
     "noUncheckedIndexedAccess": true,
     "lib": ["dom", "ESNext", "dom.iterable"],
-    "declaration": false,
+    "declaration": true,
     "noEmit": false,
     "paths": {
       "@botpress/zai": ["./src/zai.ts"]
@@ -24,7 +25,6 @@
   },
   "exclude": ["node_modules", "dist"],
   "include": ["src/**/*", "vitest.d.ts"],
-
   "ts-node": {
     "esm": true,
     "require": ["dotenv/config", "./ensure-env.cjs"]

package/scripts/update-models.mts

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

@@ -1,49 +0,0 @@
-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/tsup.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  splitting: false,
-  format: ['esm', 'cjs'],
-  sourcemap: true,
-  keepNames: true,
-  dts: true,
-  platform: 'browser',
-  clean: true,
-  shims: true,
-  external: ['react', 'react-dom'],
-  bundle: true,
-  plugins: []
-})

package/vitest.config.ts

@@ -1,9 +0,0 @@
-import 'dotenv/config'
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    include: ['./src/**/*.test.ts'],
-    setupFiles: './vitest.setup.ts'
-  }
-})

package/vitest.setup.ts

@@ -1,24 +0,0 @@
-import { Client } from '@botpress/client'
-import { setupClient } from '@botpress/vai'
-
-import { beforeAll } from 'vitest'
-
-globalThis.STUDIO = false
-
-beforeAll(async () => {
-  if (!process.env.CLOUD_PAT) {
-    throw new Error('Missing CLOUD_PAT')
-  }
-
-  if (!process.env.CLOUD_BOT_ID) {
-    throw new Error('Missing CLOUD_BOT_ID')
-  }
-
-  setupClient(
-    new Client({
-      apiUrl: process.env.CLOUD_API_ENDPOINT ?? 'https://api.botpress.dev',
-      botId: process.env.CLOUD_BOT_ID,
-      token: process.env.CLOUD_PAT
-    })
-  )
-})