@isdk/ai-tool 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,1097 @@
+import { B as BaseError, A as AIModelNameRules } from './index-D4KjfAKl.js';
+export { d as AIModelNameRule, c as AIModelNameRuleFn, m as AbortError, i as AbortErrorCode, b as ActionName, a as ActionNames, l as AlreadyExistsError, h as AlreadyExistsErrorCode, u as BaseFunc, r as BaseFuncItem, y as ClientFuncItem, D as ClientToolFuncSchema, z as ClientTools, C as CommonError, f as ErrorCode, E as ErrorCodeType, a1 as EventClient, a0 as EventClientFuncParams, a4 as EventServer, a3 as EventServerFuncParams, M as EventToolFunc, s as FuncItem, p as FuncParam, F as FuncParamType, q as FuncParams, v as Funcs, I as InternalErrorCode, k as NotFoundError, g as NotFoundErrorCode, j as NotImplementationError, N as NotImplementedErrorCode, P as PASSING_SCORE, e as RemoteFuncItem, R as RemoteToolFuncSchema, a6 as ResClientFuncParams, a7 as ResClientTools, a8 as ResClientToolsSchema, a9 as ResServerFuncParams, aa as ResServerTools, ab as ResServerToolsSchema, o as SSEChannel, S as SSEChannelAlreadyClosedErrCode, H as ServerFuncItem, G as ServerFuncParams, K as ServerToolFuncSchema, J as ServerTools, T as TFunc, w as ToolFunc, x as ToolFuncSchema, _ as _lrucache, n as createError, Q as createLRUCache, O as event, a2 as eventClient, a5 as eventServer, W as getDefaultSimilarPassingScore, X as isSimilar, U as lrucache, Z as mergeSegments, L as registerCoreTools, $ as segments, V as similarity, Y as splitSegments, t as throwError } from './index-D4KjfAKl.js';
+import { BaseFactory } from 'custom-factory';
+import * as custom_ability from 'custom-ability';
+import { Event } from 'events-ex';
+import * as _base32768 from 'base32768';
+export { NIL as uuidNIL, parse as uuidParse, stringify as uuidStringify, validate as uuidValidate, version as uuidVersion, v1 as uuidv1, v4 as uuidv4, v5 as uuidv5 } from 'uuid';
+export * from 'json-canonicalize';
+export { stringify as stringifyYaml } from 'yaml';
+export { mimeType } from 'mime-type/with-db';
+export { Config as ConfigFile } from 'load-config-file';
+import 'property-manager';
+import 'secondary-cache';
+import 'http';
+import 'abstract-error';
+
+declare const AITextGenerationFinishReasons: readonly ["stop", "length", "content-filter", "tool-calls", "abort", "error", "other", null];
+type AITextGenerationFinishReason = typeof AITextGenerationFinishReasons[number];
+interface AIResult<TValue = any, TOptions = any> {
+    /**
+     * The generated value.
+     */
+    content?: TValue;
+    /**
+     * The reason why the generation stopped.
+     */
+    finishReason?: AITextGenerationFinishReason;
+    options?: TOptions;
+    /**
+     * for stream mode
+     */
+    stop?: boolean;
+}
+declare const AIMessageTypes: readonly ["human", "ai", "generic", "system", "tool"];
+type AIMessageType = typeof AIMessageTypes[number];
+declare const AIChatRoles: readonly ["user", "assistant", "system", "tool", "tool_calls"];
+type AIChatRole = (typeof AIChatRoles[number]) & string;
+type AIChatMessageParam = AIChatSystemMessageParam | AIChatUserMessageParam | AIChatAssistantMessageParam | AIChatToolMessageParam;
+interface AIChatMessageParamBase {
+    role: string;
+    [name: string]: any;
+}
+interface AIChatSystemMessageParam extends AIChatMessageParamBase {
+    role: 'system';
+    content: string;
+    templateFormat?: string;
+}
+interface AIChatUserMessageParam extends AIChatMessageParamBase {
+    role: 'user';
+    content: string | Array<AIChatContentPart>;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    charId?: string;
+    from?: 'speech' | string;
+    templateFormat?: string;
+}
+type AIChatContentPart = AIChatContentPartText | AIChatContentPartImage;
+interface AIChatContentPartImage {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
+interface AIChatContentPartText {
+    type: 'text';
+    text: string;
+}
+interface AIChatAssistantMessageParam extends AIChatMessageParamBase {
+    role: 'assistant';
+    content?: string | null;
+    tool_calls?: Array<AIChatMessageToolCall>;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    templateFormat?: string;
+}
+interface AIChatMessageToolCall {
+    type: 'function';
+    id: string;
+    function: {
+        arguments: string;
+        name: string;
+    };
+}
+interface AIChatToolMessageParam extends AIChatMessageParamBase {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+    templateFormat?: string;
+}
+
+/**
+ * Prompt Type
+ * defaults to `chat`
+ */
+declare const PromptTypes: readonly ["chat", "char", "plan"];
+type PromptType = typeof PromptTypes[number];
+declare const PromptTemplateTypes: readonly ["internal", "hf", "fill"];
+type PromptTemplateType = typeof PromptTemplateTypes[number];
+
+declare const defaultTemplateFormat = "default";
+interface PromptTemplateOptions {
+    template?: string;
+    data?: Record<string, any>;
+    templateFormat?: string;
+    inputVariables?: string[];
+    compiledTemplate?: any;
+    ignoreInitialize?: boolean;
+    [name: string]: any;
+}
+declare class PromptTemplate extends BaseFactory {
+    compiledTemplate: any;
+    template: string;
+    templateFormat: string | undefined;
+    data: Record<string, any> | undefined;
+    inputVariables: string[] | undefined;
+    static from(template?: string | PromptTemplateOptions, options?: PromptTemplateOptions): PromptTemplate;
+    static format(options: PromptTemplateOptions): Promise<string>;
+    /**
+     * If the given options.template is the template, perform formatting using that template.
+     * @param options - The options object to check for being a template and to format.
+     * @returns A Promise that resolves to the formatted result if options is a template; otherwise, no value is returned.
+     */
+    static formatIf(options: PromptTemplateOptions): Promise<string | undefined>;
+    static isTemplate(templateOpt: PromptTemplateOptions): any;
+    /**
+     * Validate/filter the data in inputVariables
+     * @param data
+     * @returns
+     */
+    filterData(data: Record<string, any>): Record<string, any>;
+    constructor(template?: string | PromptTemplateOptions, options?: PromptTemplateOptions);
+    _initialize(options?: PromptTemplateOptions): void;
+    initialize(options?: PromptTemplateOptions): void;
+    _format(data: Record<string, any>): string | Promise<string>;
+    format(data?: Record<string, any>): Promise<string>;
+    /**
+     * it can make sense to "partial" a prompt template - eg pass in a subset of the required values, as to create a new prompt template which expects only the remaining subset of values.
+     * @param data the partial data
+     * @returns the new partial PromptTemplate instance
+     */
+    partial(data: Record<string, any>): PromptTemplate;
+    toJSON(options?: PromptTemplateOptions): PromptTemplateOptions;
+}
+
+type PromptExamples<T = any> = Iterable<PromiseLike<T> | T> | AsyncIterable<T>;
+interface PromptExampleSelectorOptions {
+    /**
+     * The maximum count of the selected examples, or `undefined` if no limit.
+     */
+    maxLength?: number;
+    /**
+     * The threshold probability (0-1) at which a sample is selected.
+     * If `true`, defaults to 0.5; if `false`, disable it.
+     */
+    threshold?: number | boolean;
+    [name: string]: any;
+}
+/**
+ * The `PromptExampleSelector` class provides a mechanism to selectively choose examples from a given set based on
+ * configurable options such as maximum length and probability threshold. This class is meant to be extended and customized
+ * with an implementation of the `selectExample` method.
+ *
+ * @template T The type of the prompt examples.
+ *
+ * @example
+ *
+ * // Custom selector that selects examples based on a custom condition
+ * class MyPromptExampleSelector extends PromptExampleSelector<string> {
+ *   selectExample(example: string, threshold?: number): string | void {
+ *     if (example.includes('keyword')) {
+ *       return super.selectExample(example, threshold);
+ *     }
+ *   }
+ * }
+ *
+ * // Create an instance with examples and options
+ * const examples = ['example1', 'keyword1', 'keyword2', 'keyword3', 'example2', 'keyword4'];
+ * const selector = new MyPromptExampleSelector(examples, { maxLength: 2, threshold: 0.8 });
+ *
+ * // Iterate through selected examples
+ * for await (const selectedExample of selector) {
+ *   console.log(selectedExample);
+ * }
+ *
+ */
+declare class PromptExampleSelector<T = any> {
+    maxLength: number | undefined;
+    /**
+     * The probability threshold (0-1) for selecting an example. If `undefined`, no filtering by probability occurs.
+     */
+    threshold: number | undefined;
+    /**
+     * The collection of prompt examples.
+     */
+    examples: PromptExamples<T>;
+    /**
+     * Constructs a new `PromptExampleSelector` instance with the given examples and options.
+     * @param examples - The prompt examples to select from.
+     * @param options - An optional configuration object.
+     */
+    constructor(examples: PromptExamples<T>, options?: PromptExampleSelectorOptions);
+    /**
+     * Initializes the selector with examples and options.
+     * @param examples - The prompt examples to select from.
+     * @param options - An optional configuration object.
+     */
+    initialize(examples: PromptExamples<T>, options?: PromptExampleSelectorOptions): void;
+    /**
+     * Select an example. Can overwrite this in subclasses.
+     * @param example - The example to potentially select.
+     * @param [threshold] - report the current probability [0-1) for the selecting example.
+     * @returns The selected example, or `undefined` if not selected.
+     */
+    selectExample(example: T, threshold?: number): T | void;
+    /**
+     * Asynchronously selects examples from the given examples, applying the configured threshold (if any).
+     * @param examples - The examples to select from. Defaults to the selector's examples if not provided.
+     * @returns An asynchronous iterator yielding selected examples.
+     */
+    selectExamples(examples?: PromptExamples<T>): AsyncGenerator<Awaited<T>, void, unknown>;
+    /**
+     * Returns an asynchronous iterator for the selected examples.
+     * @returns An asynchronous iterator over the selected examples.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
+}
+
+/**
+ * Represents tokens that our language understands in parsing.
+ */
+declare const TOKEN_TYPES: Readonly<{
+    Text: "Text";
+    NumericLiteral: "NumericLiteral";
+    BooleanLiteral: "BooleanLiteral";
+    StringLiteral: "StringLiteral";
+    Identifier: "Identifier";
+    Equals: "Equals";
+    OpenParen: "OpenParen";
+    CloseParen: "CloseParen";
+    OpenStatement: "OpenStatement";
+    CloseStatement: "CloseStatement";
+    OpenExpression: "OpenExpression";
+    CloseExpression: "CloseExpression";
+    OpenSquareBracket: "OpenSquareBracket";
+    CloseSquareBracket: "CloseSquareBracket";
+    OpenCurlyBracket: "OpenCurlyBracket";
+    CloseCurlyBracket: "CloseCurlyBracket";
+    Comma: "Comma";
+    Dot: "Dot";
+    Colon: "Colon";
+    Pipe: "Pipe";
+    CallOperator: "CallOperator";
+    AdditiveBinaryOperator: "AdditiveBinaryOperator";
+    MultiplicativeBinaryOperator: "MultiplicativeBinaryOperator";
+    ComparisonBinaryOperator: "ComparisonBinaryOperator";
+    UnaryOperator: "UnaryOperator";
+    Set: "Set";
+    If: "If";
+    For: "For";
+    In: "In";
+    Is: "Is";
+    NotIn: "NotIn";
+    Else: "Else";
+    EndIf: "EndIf";
+    ElseIf: "ElseIf";
+    EndFor: "EndFor";
+    And: "And";
+    Or: "Or";
+    Not: "UnaryOperator";
+}>;
+type TokenType = keyof typeof TOKEN_TYPES;
+/**
+ * Represents a single token in the template.
+ */
+declare class Token {
+    value: string;
+    type: TokenType;
+    /**
+     * Constructs a new Token.
+     * @param {string} value The raw value as seen inside the source code.
+     * @param {TokenType} type The type of token.
+     */
+    constructor(value: string, type: TokenType);
+}
+interface PreprocessOptions {
+    trim_blocks?: boolean;
+    lstrip_blocks?: boolean;
+}
+/**
+ * Generate a list of tokens from a source string.
+ */
+declare function tokenize(source: string, options?: PreprocessOptions): Token[];
+
+/**
+ * Statements do not result in a value at runtime. They contain one or more expressions internally.
+ */
+declare class Statement {
+    isStatement: boolean;
+    type: string;
+}
+/**
+ * Defines a block which contains many statements. Each chat template corresponds to one Program.
+ */
+declare class Program extends Statement {
+    body: Statement[];
+    type: string;
+    constructor(body: Statement[]);
+}
+
+/**
+ * Generate the Abstract Syntax Tree (AST) from a list of tokens.
+ * Operator precedence can be found here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table
+ */
+declare function parse(tokens: Token[]): Program;
+
+type AnyRuntimeValue = NumericValue | StringValue | BooleanValue | ObjectValue | ArrayValue | FunctionValue | NullValue | UndefinedValue;
+/**
+ * Abstract base class for all Runtime values.
+ * Should not be instantiated directly.
+ */
+declare abstract class RuntimeValue<T> {
+    type: string;
+    value: T;
+    /**
+     * A collection of built-in functions for this type.
+     */
+    builtins: Map<string, AnyRuntimeValue>;
+    /**
+     * Creates a new RuntimeValue.
+     */
+    constructor(value?: T);
+    /**
+     * Determines truthiness or falsiness of the runtime value.
+     * This function should be overridden by subclasses if it has custom truthiness criteria.
+     * @returns {BooleanValue} BooleanValue(true) if the value is truthy, BooleanValue(false) otherwise.
+     */
+    __bool__(): BooleanValue;
+    toString(): string;
+    toJSON(): any;
+}
+/**
+ * Represents a numeric value at runtime.
+ */
+declare class NumericValue extends RuntimeValue<number> {
+    type: string;
+}
+/**
+ * Represents a string value at runtime.
+ */
+declare class StringValue extends RuntimeValue<string> {
+    type: string;
+    builtins: Map<string, AnyRuntimeValue>;
+}
+/**
+ * Represents a boolean value at runtime.
+ */
+declare class BooleanValue extends RuntimeValue<boolean> {
+    type: string;
+}
+/**
+ * Represents an Object value at runtime.
+ */
+declare class ObjectValue extends RuntimeValue<Map<string, AnyRuntimeValue>> {
+    orgValue?: Record<string, any> | undefined;
+    type: string;
+    constructor(value: Map<string, AnyRuntimeValue>, orgValue?: Record<string, any> | undefined);
+    toString(): string;
+    toJSON(): Record<string, any>;
+    /**
+     * NOTE: necessary to override since all JavaScript arrays are considered truthy,
+     * while only non-empty Python arrays are consider truthy.
+     *
+     * e.g.,
+     *  - JavaScript:  {} && 5 -> 5
+     *  - Python:      {} and 5 -> {}
+     */
+    __bool__(): BooleanValue;
+    builtins: Map<string, AnyRuntimeValue>;
+}
+/**
+ * Represents an Array value at runtime.
+ */
+declare class ArrayValue extends RuntimeValue<AnyRuntimeValue[]> {
+    type: string;
+    builtins: Map<string, AnyRuntimeValue>;
+    /**
+     * NOTE: necessary to override since all JavaScript arrays are considered truthy,
+     * while only non-empty Python arrays are consider truthy.
+     *
+     * e.g.,
+     *  - JavaScript:  [] && 5 -> 5
+     *  - Python:      [] and 5 -> []
+     */
+    __bool__(): BooleanValue;
+}
+/**
+ * Represents a Function value at runtime.
+ */
+declare class FunctionValue extends RuntimeValue<(args: AnyRuntimeValue[], scope: Environment) => AnyRuntimeValue> {
+    type: string;
+}
+/**
+ * Represents a Null value at runtime.
+ */
+declare class NullValue extends RuntimeValue<null> {
+    type: string;
+}
+/**
+ * Represents an Undefined value at runtime.
+ */
+declare class UndefinedValue extends RuntimeValue<undefined> {
+    type: string;
+}
+/**
+ * Represents the current environment (scope) at runtime.
+ */
+declare class Environment {
+    parent?: Environment | undefined;
+    /**
+     * The variables declared in this environment.
+     */
+    variables: Map<string, AnyRuntimeValue>;
+    /**
+     * The tests available in this environment.
+     */
+    tests: Map<string, (...value: AnyRuntimeValue[]) => boolean>;
+    constructor(parent?: Environment | undefined);
+    /**
+     * Set the value of a variable in the current environment.
+     */
+    set(name: string, value: unknown): AnyRuntimeValue;
+    private declareVariable;
+    /**
+     * Set variable in the current scope.
+     * See https://jinja.palletsprojects.com/en/3.0.x/templates/#assignments for more information.
+     */
+    setVariable(name: string, value: AnyRuntimeValue): AnyRuntimeValue;
+    /**
+     * Resolve the environment in which the variable is declared.
+     * @param {string} name The name of the variable.
+     * @returns {Environment} The environment in which the variable is declared.
+     */
+    private resolve;
+    lookupVariable(name: string): AnyRuntimeValue;
+}
+declare class Interpreter {
+    global: Environment;
+    constructor(env?: Environment);
+    /**
+     * Run the program.
+     */
+    run(program: Program): AnyRuntimeValue;
+    /**
+     * Evaluates expressions following the binary operation type.
+     */
+    private evaluateBinaryExpression;
+    /**
+     * Evaluates expressions following the filter operation type.
+     */
+    private evaluateFilterExpression;
+    /**
+     * Evaluates expressions following the test operation type.
+     */
+    private evaluateTestExpression;
+    /**
+     * Evaluates expressions following the unary operation type.
+     */
+    private evaluateUnaryExpression;
+    private evalProgram;
+    private evaluateBlock;
+    private evaluateIdentifier;
+    private evaluateCallExpression;
+    private evaluateSliceExpression;
+    private evaluateMemberExpression;
+    private evaluateSet;
+    private evaluateIf;
+    private evaluateFor;
+    evaluate(statement: Statement | undefined, environment: Environment): AnyRuntimeValue;
+}
+
+declare function randomInt(to: number, from?: number): number;
+/**
+ * Selects an element from the given object, array, or string.
+ * @param obj Can be an object, array, or string to select from.
+ * @param index Optional, specifies the index or key to select. Negative values indicate indices from the end.
+ * @returns The selected element, or `undefined` if the input is empty or not provided.
+ *
+ * @example
+ * // Selecting an element from an array
+ * const array = ['apple', 'banana', 'cherry']
+ * console.log(select(array)) // Random element from the array
+ * console.log(select(array, 1)) // Second element
+ * console.log(select(array, -1)) // Last element
+ *
+ * @example
+ * // Selecting a property from an object
+ * const obj = { fruit1: 'apple', fruit2: 'banana', fruit3: 'cherry' }
+ * console.log(select(obj)) // Random property from the object
+ * console.log(select(obj, 'fruit2')) // Property with key 'fruit2'
+ *
+ * @example
+ * // Selecting a character from a string
+ * const str = 'hello'
+ * console.log(select(str)) // Random character from the string
+ * console.log(select(str, 1)) // Second character
+ * console.log(select(str, -1)) // Last character
+ */
+declare function select(obj: any | any[], index?: number | string): any;
+declare const builtins: {
+    randomInt: typeof randomInt;
+    select: typeof select;
+};
+
+/**
+ * @file Jinja templating engine
+ *
+ * A minimalistic JavaScript reimplementation of the [Jinja](https://github.com/pallets/jinja) templating engine,
+ * to support the chat templates. Special thanks to [Tyler Laceby](https://github.com/tlaceby) for his amazing
+ * ["Guide to Interpreters"](https://github.com/tlaceby/guide-to-interpreters-series) tutorial series,
+ * which provided the basis for this implementation.
+ *
+ * See the [Transformers documentation](https://huggingface.co/docs/transformers/main/en/chat_templating) for more information.
+ *
+ * @module index
+ */
+
+declare class EnvironmentEx extends Environment {
+    parent?: EnvironmentEx | undefined;
+    constructor(parent?: EnvironmentEx | undefined);
+    assign(items: Record<string, unknown>): void;
+    clear(): void;
+}
+declare class Template {
+    parsed: Program;
+    static global: EnvironmentEx;
+    /**
+     * @param {string} template The template string
+     */
+    constructor(template: string, options?: PreprocessOptions);
+    render(items: Record<string, unknown>): string;
+}
+
+declare class HfPromptTemplate extends PromptTemplate {
+    compiledTemplate: Template;
+    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean;
+    getVariables(template?: Template): string[];
+    _initialize(options?: PromptTemplateOptions): void;
+    _format(data: Record<string, any>): string;
+}
+declare function createHfValueFunc(fn: Function): (_data: any) => Function;
+
+/**
+ * Type that represents a node in a parsed format string. It can be either
+ * a literal text or a variable name.
+ */
+type FStringPromptTemplateNode = {
+    type: "literal";
+    text: string;
+} | {
+    type: "variable";
+    name: string;
+};
+/**
+ * Type that represents a function that takes a template string and
+ * returns an array of `ParsedFStringNode`.
+ *
+ * extract from langchain.js/langchain-core/src/prompts/template.ts
+ */
+declare function parseFString(template: string): FStringPromptTemplateNode[];
+/**
+ * Type that represents a function that takes a template string and a set
+ * of input values, and returns a string where all variables in the
+ * template have been replaced with their corresponding values.
+ */
+declare function interpolateFString(nodes: FStringPromptTemplateNode[], values: Record<string, any>): string;
+
+declare class FStringPromptTemplate extends PromptTemplate {
+    compiledTemplate: FStringPromptTemplateNode[];
+    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean;
+    getVariables(template?: FStringPromptTemplateNode[]): string[];
+    _initialize(options?: PromptTemplateOptions): void;
+    _format(data: Record<string, any>): string;
+}
+
+declare class GolangPromptTemplate extends PromptTemplate {
+    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean | undefined;
+    getVariables(template: string): string[];
+    _initialize(options?: PromptTemplateOptions): void;
+    _format(data: Record<string, any>): string;
+}
+
+declare function sortedValues<T>(values: Record<string, T>): T[];
+interface FewShotPromptTemplateOptions<T = any> extends PromptTemplateOptions {
+    /**
+     * The few shot examples to use in the prompt.
+     */
+    examples: PromptExamples<T>;
+    /**
+     * An {@link PromptTemplate} used to format a single example.
+     */
+    examplePrompt: PromptTemplate | PromptTemplateOptions;
+    /**
+     * String separator used to join the prefix, the examples, and suffix.
+     */
+    exampleSeparator?: string;
+    /**
+     * A prompt template string to put before the examples.
+     *
+     * @defaultValue `""`
+     */
+    prefix?: string;
+    /**
+     * A prompt template string to put after the examples.
+     */
+    suffix?: string;
+}
+declare class FewShotPromptTemplate<T = any> extends PromptTemplate {
+    examples: PromptExamples<T>;
+    examplePrompt: PromptTemplate | undefined;
+    suffix: string;
+    exampleSeparator: string;
+    prefix: string;
+    static from<T = any>(options: FewShotPromptTemplateOptions<T>): FewShotPromptTemplate<T>;
+    constructor(options: FewShotPromptTemplateOptions<T>);
+    _initialize(options?: FewShotPromptTemplateOptions<T>): void;
+    _format(data: Record<string, any>): Promise<string>;
+    toJSON(options?: this): FewShotPromptTemplateOptions<T>;
+}
+
+/**
+ * Parse and interpolate template
+ * @param str golang style template
+ * @param variables object of variables to insert
+ */
+declare function interpolateGolangTemplate(str: string, variables: Record<string, any>, initVars?: boolean): string;
+
+declare function interpolateEnv(value: string, processEnv: any, parsed: any): any;
+/**
+ * Expand environment variables in the parsed object
+ * @param options.processEnv Specify an object to write your secrets to. Defaults to `process.env` environment variables.
+ * @param options.parsed Specify an object to provide the value of environment variables.
+ *
+ * Follows these rules to handle environment variable expansion:
+ *
+ * 1. Simple Variable Expansion: If a string contains `$KEY`, it will be replaced by the value of the environment variable named `KEY`.
+ * 2. Braced Variable Expansion: When a string contains `${KEY}`, it also looks up the environment variable named `KEY`.
+ *    This syntax is typically used to disambiguate variable names that contain special characters.
+ * 3. Escaped Dollar Sign: If you want to include a literal `$` followed by a variable name, you can escape it with a backslash (`\$KEY`).
+ *    This ensures the `$` character is treated as part of the literal string rather than a variable reference.
+ * 4. Default Value: In the case of `${KEY:-default}` or `${KEY-default}`, the engine first tries to expand the KEY environment variable.
+ *    If there's no such environment variable, it will use default as the fallback value.
+ *
+ * @example
+ * const myEnv = {}
+ * const env = {
+ *   processEnv: myEnv,
+ *   parsed: {
+ *     WORD: 'World',
+ *     HELLO: 'Hello ${WORD}'
+ *   }
+ * }
+ * expandEnv.expand(env)
+ *
+ * console.log(myEnv.HELLO) // Hello World
+ * console.log(process.env.HELLO) // undefined
+ */
+declare function expandEnv(options: DotenvExpandOptions): DotenvExpandOptions;
+/**
+ * Expands environment variables in an object/array or string.
+ *
+ * This function replaces placeholders like `${VAR}` in strings and recursively
+ * processes objects and arrays with environment variable references.
+ *
+ * @param obj - The object/array or string to be processed. Can be any value, but
+ *              primarily designed for objects, array and strings.
+ * @param options - Configuration options:
+ *   - processEnv: - An object to source environment variables from, defaults to `process.env`.
+ *   - parsed: - Specify an object to provide the value of environment variables.
+ * @returns - Returns the expanded object or string.
+ *
+ * @example
+ * const obj = {
+ *   name: 'MyApp',
+ *   envVar: '${ENV_VAR_NAME}',
+ *   config: {
+ *     url: 'http://${HOST}:${PORT}'
+ *   },
+ *   list: ['item1', '${ITEM2}']
+ * };
+ * // the expandedObj will have the actual values instead of placeholders.
+ * const expandedObj = expandObjEnv(obj, { processEnv: myCustomEnv }); // Assuming 'ENV_VAR_NAME' is defined as 'Production' and 'HOST', 'PORT', 'ITEM2' are set,
+ *
+ */
+declare function expandObjEnv(obj: any, options?: DotenvExpandOptions, parsedObjs?: WeakSet<any>): any;
+interface DotenvPopulateInput {
+    [name: string]: string | undefined;
+}
+interface DotenvParseInput {
+    [name: string]: string | undefined;
+}
+interface DotenvParseOutput {
+    [name: string]: string | undefined;
+}
+interface DotenvExpandOptions {
+    error?: Error;
+    /**
+     * Default: `process.env`
+     *
+     * Specify an object to write your secrets to. Defaults to process.env environment variables.
+     *
+     * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+     */
+    processEnv?: DotenvPopulateInput;
+    /**
+     * Default: `object`
+     *
+     * Object coming from dotenv's parsed result.
+     */
+    parsed?: DotenvParseInput;
+}
+interface DotenvExpandOutput {
+    error?: Error;
+    parsed?: DotenvParseOutput;
+}
+
+/**
+ * Splits a text into sentences.
+ * This function is used to split a text into separate sentences, based on punctuation marks such as '.', '?', or '!' and other rules.
+ * @param {string} text - The input string that needs to be split into sentences.
+ * @param {boolean} best - A boolean flag indicating if the function should use the best possible sentence splitting method (default is true).
+ * If set to false, it will not perform any additional processing and simply split on newline characters ('\n').
+ * @returns {string[]} An array of strings where each string represents a sentence in the input text.
+ *
+ * Example:
+ * const text = "Hello world! How are you today? I am fine.";
+ * console.log(splitSentence(text));  // returns ['Hello world!', 'How are you today?', 'I am fine.']
+ */
+declare function splitSentence(text: string, best?: boolean): string[];
+
+/**
+ * Truncates(Round) a number to a specified number of decimal places.
+ *
+ * @param {number} n - The number to truncate.
+ * @param {number} dec - The number of decimal places to truncate to (default is 2).
+ * @param {number} up - The amount to round up by before truncating (default is 0.5).
+ *
+ * @example
+ * // returns 1.235
+ * truncTo(1.2345, 3)
+ *
+ * @example
+ * // returns 1.24
+ * truncTo(1.2345, 2, 0.6)
+ *
+ * @returns {number} The truncated number.
+ */
+declare function truncTo(n: number, dec?: number, up?: number): number;
+
+declare function wait(ms: number): Promise<void>;
+
+declare const EventName = "event";
+declare const EventBusName = "event-bus";
+type EventListenerFn = (this: Event, name: string, ...args: any) => any;
+type EventErrorListenerFn = (this: Event, err: Error, name: string, ...args: any) => any;
+declare const backendEventable: custom_ability.AbilityFn;
+
+declare const RStreamErrCode = 600;
+declare const ResponseRStreamErrCode = 601;
+declare class ReadableStreamError extends BaseError {
+    constructor(msg: string, code?: number);
+}
+declare function getResponseErrorReadableStream(body?: ReadableStream<Uint8Array> | null): ReadableStream<any>;
+
+/**
+ * Creates an empty ReadableStream that immediately closes upon creation.
+ * This function is used as a fallback for creating a ReadableStream when the response body is null or undefined,
+ * ensuring that the subsequent pipeline processing doesn't fail due to a lack of a stream.
+ *
+ * @returns {ReadableStream} An empty and closed ReadableStream instance.
+ */
+declare function createEmptyReadableStream(): ReadableStream;
+
+/**
+ * Configuration options and helper callback methods for AIStream stream lifecycle events.
+ * @interface
+ */
+interface AIStreamCallbacksAndOptions {
+    /** `onStart`: Called once when the stream is initialized. */
+    onStart?: () => Promise<void> | void;
+    /** `onCompletion`: Called for each tokenized message. */
+    onCompletion?: (completion: string) => Promise<void> | void;
+    /** `onFinal`: Called once when the stream is closed with the final completion message. */
+    onFinal?: (completion: string) => Promise<void> | void;
+    /** `onToken`: Called for each tokenized message. */
+    onToken?: (token: string) => Promise<void> | void;
+    /** `onText`: Called for each text chunk. */
+    onText?: (text: string) => Promise<void> | void;
+    /**
+     * A flag for enabling the experimental_StreamData class and the new protocol.
+     * @see https://github.com/vercel-labs/ai/pull/425
+     *
+     * When StreamData is rolled out, this will be removed and the new protocol will be used by default.
+     */
+    experimental_streamData?: boolean;
+}
+/**
+ * Options for the AIStreamParser.
+ * @interface
+ * @property {string} event - The event (type) from the server side event stream.
+ */
+interface AIStreamParserOptions {
+    event?: string;
+}
+/**
+ * Custom parser for AIStream data.
+ * @interface
+ * @param {string} data - The data to be parsed.
+ * @param {AIStreamParserOptions} options - The options for the parser.
+ * @returns The parsed data or void.
+ */
+interface AIStreamParser<T = any, TOptions = any> {
+    (data: string, options: AIStreamParserOptions): AIResult<T, TOptions> | void;
+}
+/**
+ * Creates a TransformStream that parses events from an EventSource stream using a custom parser.
+ * @param {AIStreamParser} customParser - Function to handle event data.
+ * @returns TransformStream parsing events.
+ */
+declare function createEventStreamTransformer<TValue = any, TOptions = any>(customParser?: AIStreamParser): TransformStream<Uint8Array, AIResult<TValue, TOptions>>;
+/**
+ * Creates a transform stream that encodes input messages and invokes optional callback functions.
+ * The transform stream uses the provided callbacks to execute custom logic at different stages of the stream's lifecycle.
+ * - `onStart`: Called once when the stream is initialized.
+ * - `onToken`: Called for each tokenized message.
+ * - `onCompletion`: Called every time an AIStream completion message is received. This can occur multiple times when using e.g. OpenAI functions
+ * - `onFinal`: Called once when the stream is closed with the final completion message.
+ *
+ * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
+ *
+ * @param {AIStreamCallbacksAndOptions} [callbacks] - An object containing the callback functions.
+ * @return {TransformStream<string, Uint8Array>} A transform stream that encodes input messages as Uint8Array and allows the execution of custom logic through callbacks.
+ *
+ * @example
+ * const callbacks = {
+ *   onStart: async () => console.log('Stream started'),
+ *   onToken: async (token) => console.log(`Token: ${token}`),
+ *   onCompletion: async (completion) => console.log(`Completion: ${completion}`)
+ *   onFinal: async () => data.close()
+ * };
+ * const transformer = createCallbacksTransformer(callbacks);
+ */
+declare function createCallbacksTransformer(cb: AIStreamCallbacksAndOptions | undefined): TransformStream<AIResult, Uint8Array>;
+/**
+ * Returns a stateful function that, when invoked, trims leading whitespace
+ * from the input text. The trimming only occurs on the first invocation, ensuring that
+ * subsequent calls do not alter the input text. This is particularly useful in scenarios
+ * where a text stream is being processed and only the initial whitespace should be removed.
+ *
+ * @return {function(string): string} A function that takes a string as input and returns a string
+ * with leading whitespace removed if it is the first invocation; otherwise, it returns the input unchanged.
+ *
+ * @example
+ * const trimStart = trimStartOfStreamHelper();
+ * const output1 = trimStart("   text"); // "text"
+ * const output2 = trimStart("   text"); // "   text"
+ *
+ */
+declare function trimStartOfStreamHelper(): (text: string) => string;
+/**
+ * Returns a ReadableStream created from the response, parsed and handled with custom logic.
+ * The stream goes through two transformation stages, first parsing the events and then
+ * invoking the provided callbacks.
+ *
+ * For 2xx HTTP responses:
+ * - The function continues with standard stream processing.
+ *
+ * For non-2xx HTTP responses:
+ * - If the response body is defined, it asynchronously extracts and decodes the response body.
+ * - It then creates a custom ReadableStream to propagate a detailed error message.
+ *
+ * @param {Response} response - The response.
+ * @param {AIStreamParser} customParser - The custom parser function.
+ * @param {AIStreamCallbacksAndOptions} callbacks - The callbacks.
+ * @return {ReadableStream} The AIStream.
+ * @throws Will throw an error if the response is not OK.
+ */
+declare function AIStream<T = any, TOptions = any>(response: Response, customParser?: AIStreamParser<T, TOptions>): ReadableStream<AIResult<T, TOptions>>;
+/**
+ * Implements ReadableStream.from(asyncIterable), which isn't documented in MDN and isn't implemented in node.
+ * https://github.com/whatwg/streams/commit/8d7a0bf26eb2cc23e884ddbaac7c1da4b91cf2bc
+ */
+declare function readableFromAsyncIterable<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
+
+declare function uuid(ver?: 1 | 4 | 5, encode?: boolean): string;
+
+declare const base32768: typeof _base32768;
+
+declare function xxhash32(value: string | object, radix?: number): string;
+declare function xxhash64(value: string | object, radix?: number): string;
+declare enum XXHashAlgorithm {
+    xxhash64 = 111,
+    xxhash32 = 112
+}
+type HashValue = string | ArrayBuffer | Buffer;
+declare function xxhash(value: HashValue, hashAlgo?: XXHashAlgorithm, seed?: number): Uint8Array;
+declare function xxhashAsStr(value: string | Uint8Array, hashAlgo?: XXHashAlgorithm, seed?: number): string;
+
+/**
+ * Regular expression pattern for reserved characters in a filename.
+ * do not use /g global option here: when the regex is executed multiple times, it will always begin where it left off last time.
+ */
+declare const FilenameReservedRegex: RegExp;
+/**
+ * Regular expression pattern for reserved names on Windows systems.
+ */
+declare const WindowsReservedNameRegex: RegExp;
+/**
+ * Returns a new regular expression instance for reserved filename characters with the 'g' flag.
+ * use this to reset the with global option
+ * @returns A compiled regular expression for reserved filename characters.
+ */
+declare function filenameReservedRegex(): RegExp;
+/**
+ * Returns a new regular expression instance for control characters in a filename with the 'g' flag.
+ * @returns A compiled regular expression for control characters in a filename.
+ */
+declare function reControlCharsRegex(): RegExp;
+/**
+ * Validates if a given string is a valid filename.
+ * @param {string} filename - The filename to be validated.
+ * @returns True if the filename is valid, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ * @example
+* isValidFilename('myFile.txt'); // Returns true
+* isValidFilename('my<file.txt'); // Returns false
+*/
+declare function isValidFilename(filename: string): boolean | "";
+/**
+ * Validates whether the given filepath is valid.
+ * @param filepath - The filepath to be checked, represented as a string.
+ * @returns A boolean indicating whether the filepath is valid. Returns true if valid; false otherwise.
+ */
+declare function isValidFilepath(filepath: string): boolean;
+interface SanitizeFilenameOptions {
+    replacement?: string;
+    maxLength?: number;
+}
+/**
+ * Sanitizes a given filename by replacing invalid characters with a specified replacement character or a default.
+ * @param filename - The filename to sanitize, represented as a string.
+ * @param options - An optional object containing configuration options:
+ *   - `replacement` {string} - The character to replace invalid characters with. Default is '!'. Cannot contain reserved filename characters.
+ *   - `maxLength` {number} - The maximum length of the sanitized filename. Default is `MAX_FILENAME_LENGTH`.
+ * @returns The sanitized filename.
+ * @throws {Error} - If the `replacement` contains reserved filename characters or control characters.
+ */
+declare function sanitizeFilename(filename: string, options?: SanitizeFilenameOptions): string;
+/**
+ * Sanitizes each part of a file path and reassembles it, ensuring the path is valid according to provided options.
+ * @param filepath - The file path to sanitize, represented as a string.
+ * @param options - Optional settings for sanitization, extending `SanitizeFilenameOptions`. Allows customization of replacement characters and maximum filename length.
+ * @returns The sanitized file path as a string.
+ */
+declare function sanitizeFilepath(filepath: string, options?: SanitizeFilenameOptions): string;
+/**
+ * Retrieves multi-level file extension
+ * @param filename The file name
+ * @param level The level, default is 1, indicating the number of extension levels to retrieve
+ * @returns Returns a concatenated string of multiple extensions, or an empty string if no extension is found
+ */
+declare function getMultiLevelExtname(filename: string, level?: number): string;
+/**
+ * Calculates the level of an extension name.
+ *
+ * The level represents the number of dots ('.') in the extension name, excluding the first dot which separates
+ * the base filename from the extension. For example, the level of ".txt" is 1, and the level of ".tar.gz" is 2.
+ *
+ * @param extName - The extension name to analyze. It should start with a dot ('.').
+ * @returns The level of the extension name, which is the count of dots minus one.
+ *
+ * @example
+* ```typescript
+* // Returns 0
+* extNameLevel("no-file-ext");
+*
+* // Returns 2
+* extNameLevel(".tar.gz");
+*
+* // Returns 1
+* extNameLevel(".json5");
+* ```
+*/
+declare function extNameLevel(extName: string): number;
+
+/**
+ * Checks if the provided model name matches the given rule.
+ * @param modelName The name of the model to check.
+ * @param rule An optional rule that can be a string, an array of strings, a regular expression, or a function.
+ * @returns matched result if the model name matches the rule, undefined otherwise.
+ * @example
+ * IsModelNameMatched("gpt-3", "gpt-3") // returns true
+ * IsModelNameMatched("GPT-3", "gpt-3") // returns true
+ * IsModelNameMatched("GPT-3", ["gpt-3", "gpt-4"]) // returns true
+ * IsModelNameMatched("gpt-3", /^gpt-\d+$/) // returns true
+ * IsModelNameMatched("gpt-3", (modelName) => modelName.startsWith("gpt-")) // returns true
+ * IsModelNameMatched("gpt-2", "gpt-3") // returns false
+ * IsModelNameMatched("gpt-2", ["gpt-3", "gpt-4"]) // returns false
+ * IsModelNameMatched("gpt-2", /^gpt-\d+$/) // returns false
+ * IsModelNameMatched("gpt-2", (modelName) => modelName.startsWith("gpt-")) // returns false
+ */
+declare function isModelNameMatched(modelName: string, rule?: AIModelNameRules): string | RegExpExecArray | undefined;
+
+/**
+ * Retrieves all string keys from the given enumeration(number).
+ *
+ * @param enumType - The enumeration type with numeric values for which to retrieve keys.
+ * @returns An array containing all string keys of the specified enumeration.
+ */
+declare function getAllEnumKeys<T extends object>(enumType: T): Array<keyof typeof enumType>;
+
+/**
+ * Parses a JavaScript string into a JSON object.
+ * @param input The string to be parsed into JSON.
+ * @returns The parsed JSON object. If parsing fails, undefined is returned.
+ *
+ * @example
+ * // This will return a JSON object with key 'name' and value 'John'.
+ * const jsonString = '({name: "John"})';
+ * const json = parseJsJson(jsonString);
+ * console.log(json); // { name: 'John' }
+ */
+declare function parseJsJson(input: string): any;
+
+/**
+ * Retrieves an array of all key paths as strings for a nested object or array.
+ * @param value - The object or array to extract the paths from.
+ * @returns - An array of strings containing all the key paths.
+ *
+ * @example
+* ```
+* const obj = { a: { b: { c: 1 } }, d: [0, { e: 2 }] };
+* console.log(getKeysPath(obj)); // Output: ['a.b.c', 'd[0]', 'd[1].e']
+* ```
+*/
+declare function getKeysPath<TValue extends object>(value: TValue): string[];
+
+declare function createEndWithRepetitionDetector(repetitionThreshold: number): (value: string) => boolean;
+
+/**
+ * Loads a file from given paths, optionally searching for specific extensions.
+ *
+ * @param filename - The base filename to search for, without any file extension.
+ * @param searchPaths - An array of directories to search for the file. Defaults to the current directory (`"."`) if not provided.
+ * @param extNames - An array of file extensions to try, in order of preference. If not provided, the file will be searched for
+ *                   without any extension.
+ *
+ * @returns The contents of the found file as a Buffer.
+ * @throws {NotFoundError} If the file is not found in any of the search paths.
+ *
+ * @example
+* ```typescript
+* const content = loadFileFromPaths('config', ['/etc', '/usr/local/etc'], ['.json', '.yaml']);
+* ```
+*/
+declare function loadFileFromPaths(filename: string, searchPaths?: string[], extNames?: string[]): Buffer;
+declare function loadTextFromPaths(filename: string, searchPaths?: string[], extNames?: string[], encoding?: BufferEncoding): string;
+
+declare function registerYamlTag(tags: any): void;
+declare function parseYaml(content: string): any;
+
+declare function getConfigFileNames(directoryPath: string): string[];
+declare function getConfigs(directoryPath: string): any[];
+declare function saveConfigFile(filename: string, config: any, extLevel?: number): void;
+
+interface JsonFilter {
+    [key: string]: any;
+}
+/**
+ * Converts a filter object to a SQLite WHERE clause.
+ * @param {JsonFilter} filter - The filter object to convert.
+ * @returns {string} The generated WHERE clause.
+ * @example
+ * const jsonFilter: Filter = {
+ *   $and: [
+ *     { age: { $gt: 18, $lt: 30 } },
+ *     { name: { $like: 'John%', $nlike: 'Doe%' } },
+ *     { hobbies: { $in: ['reading', 'writing'] } },
+ *     { $or: [{ gender: 'male' }, { country: 'USA' }] },
+ *     { $and: [{ status: 'active' }, { registered: new Date('2020-01-01') }] },
+ *   ],
+ * };
+ *
+ * console.log(jsonFilterToWhere(jsonFilter)); // Outputs a WHERE clause based on the given filter
+ */
+declare function jsonFilterToWhere(filter: JsonFilter | JsonFilter[], wrapKey?: (k: string) => string): string;
+
+export { type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatToolMessageParam, type AIChatUserMessageParam, type AIMessageType, AIMessageTypes, AIModelNameRules, type AIResult, AIStream, type AIStreamCallbacksAndOptions, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, BaseError, type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, EventBusName, type EventErrorListenerFn, type EventListenerFn, EventName, FStringPromptTemplate, type FStringPromptTemplateNode, FewShotPromptTemplate, type FewShotPromptTemplateOptions, FilenameReservedRegex, GolangPromptTemplate, builtins as HFBuiltins, EnvironmentEx as HFEnvironment, Interpreter as HFInterpreter, Template as HFTemplate, HfPromptTemplate, type JsonFilter, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, ReadableStreamError, ResponseRStreamErrCode, type SanitizeFilenameOptions, WindowsReservedNameRegex, XXHashAlgorithm, backendEventable, base32768, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, defaultTemplateFormat, expandEnv, expandObjEnv, extNameLevel, filenameReservedRegex, getAllEnumKeys, getConfigFileNames, getConfigs, getKeysPath, getMultiLevelExtname, getResponseErrorReadableStream, parse as hfParse, tokenize as hfTokenize, interpolateEnv, interpolateFString, interpolateGolangTemplate, isModelNameMatched, isValidFilename, isValidFilepath, jsonFilterToWhere, loadFileFromPaths, loadTextFromPaths, parseFString, parseJsJson, parseYaml, reControlCharsRegex, readableFromAsyncIterable, registerYamlTag, sanitizeFilename, sanitizeFilepath, saveConfigFile, sortedValues, splitSentence, trimStartOfStreamHelper, truncTo, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };