@isdk/ai-tool 0.0.7 → 0.0.8

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { B as BaseError, A as AIModelNameRules } from './index-japi6bEq.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, W as EventClient, V as EventClientFuncParams, Z as EventServer, Y 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, a0 as ResClientFuncParams, a1 as ResClientTools, a2 as ResClientToolsSchema, a3 as ResServerFuncParams, a4 as ResServerTools, a5 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, X as eventClient, $ as eventServer, U as lrucache, L as registerCoreTools, t as throwError } from './index-japi6bEq.js';
-import { BaseFactory } from 'custom-factory';
 import * as custom_ability from 'custom-ability';
+import { AbilityOptions } from 'custom-ability';
+export { createAbilityInjector } from 'custom-ability';
+import { A as AsyncFeatures, C as CommonError, T as ToolFunc, B as BaseError, a as AIModelNameRules } from './index-Dgo3ZXPQ.js';
+export { e as AIModelNameRule, d as AIModelNameRuleFn, n as AbortError, j as AbortErrorCode, c as ActionName, b as ActionNames, m as AlreadyExistsError, i as AlreadyExistsErrorCode, u as AsyncFeatureBits, D as BaseFunc, y as BaseFuncItem, K as ClientFuncItem, M as ClientToolFuncSchema, L as ClientTools, g as ErrorCode, E as ErrorCodeType, a1 as EventClient, a0 as EventClientFuncParams, a4 as EventServer, a3 as EventServerFuncParams, X as EventToolFunc, z as FuncItem, v as FuncParam, F as FuncParamType, w as FuncParams, G as Funcs, I as InternalErrorCode, l as NotFoundError, h as NotFoundErrorCode, k as NotImplementationError, N as NotImplementedErrorCode, P as PASSING_SCORE, f as RemoteFuncItem, R as RemoteToolFuncSchema, a6 as ResClientFuncParams, a7 as ResClientTools, a8 as ResClientToolsSchema, a9 as ResServerFuncParams, aa as ResServerTools, ab as ResServerToolsSchema, p as SSEChannel, S as SSEChannelAlreadyClosedErrCode, Q as ServerFuncItem, O as ServerFuncParams, V as ServerToolFuncSchema, U as ServerTools, x as TFunc, r as ToolAsyncCancelableBit, q as ToolAsyncMultiTaskBit, s as ToolAsyncPriorityBit, H as ToolFuncPackage, J as ToolFuncSchema, _ as _lrucache, o as createError, Z as createLRUCache, Y as event, a2 as eventClient, a5 as eventServer, $ as lrucache, W as registerCoreTools, t as throwError } from './index-Dgo3ZXPQ.js';
+import { BaseFactory } from 'custom-factory';
 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';
@@ -9,11 +11,227 @@ 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';
+export { formatISO, parse as parseDateFormat, parseISO, toDate } from 'date-fns';
 import 'property-manager';
 import 'secondary-cache';
 import 'abstract-error';
 import 'http';
 
+declare const DefaultAsyncSemaphoreCapacity = 32;
+declare class Deque {
+    private _capacity;
+    private _length;
+    private _front;
+    private arr;
+    constructor(capacity: number);
+    push(item: any): number;
+    pop(): any;
+    shift(): any;
+    get length(): number;
+    private checkCapacity;
+    private resizeTo;
+}
+/**
+ * A Semaphore implementation for managing concurrency in asynchronous operations.
+ * Semaphores allow a fixed number of resources to be accessed concurrently.
+ *
+ * Example usage:
+ *
+ * ```typescript
+ * const semaphore = new Semaphore(5); // Allows 5 concurrent operations.
+ *
+ * const semaphore = new Semaphore(
+ *   4, // Allow 4 concurrent async calls
+ *   {
+ *     capacity: 100 // Prealloc space for 100 tokens
+ *   }
+ * );
+ *
+ * async function fetchData(x) {
+ *   await semaphore.acquire()
+ *   try {
+ *     console.log(semaphore.pendingCount() + ' calls to fetch are waiting')
+ *     // ... do some async stuff with x
+ *   } finally {
+ *     semaphore.release();
+ *   }
+ * }
+ *
+ * const data = await Promise.all(array.map(fetchData));
+ * ```
+ */
+declare class Semaphore {
+    readonly maxConcurrency: number;
+    readonly waiting: Deque;
+    private free;
+    private releaseEmitter;
+    private useDefaultTokens;
+    private pauseFn?;
+    private resumeFn?;
+    private paused;
+    /**
+   * Creates a semaphore object. The first argument is the maximum concurrently number and the second argument is optional.
+   *
+   * @param maxConcurrency The maximum number of callers allowed to acquire the semaphore concurrently.
+   * @param options.initFn Function that is used to initialize the tokens used to manage the semaphore. The default is () => '1'.
+   * @param options.pauseFn An optional fuction that is called to opportunistically request pausing the the incoming stream of data,
+   *    instead of piling up waiting promises and possibly running out of memory. See examples/pausing.js.
+   * @param options.resumeFn An optional function that is called when there is room again to accept new waiters on the semaphore.
+   *    This function must be declared if a pauseFn is declared.
+   * @param options.capacity Sets the size of the preallocated waiting list inside the semaphore.
+   *    This is typically used by high performance where the developer can make a rough estimate of the number of concurrent users of a semaphore.
+   *
+   * ```ts
+   * const readline = require('readline');
+   *
+   * const rl = readline.createInterface({
+   * 	input: process.stdin,
+   * 	output: process.stdout,
+   * 	terminal: false
+   * });
+   *
+   * function pause() {
+   * 	console.log('Pausing the stream');
+   * 	rl.pause();
+   * }
+   *
+   * function resume() {
+   * 	console.log('Resuming the stream');
+   * 	rl.resume();
+   * }
+   *
+   * const s = new Semaphore(5, { pauseFn: pause, resumeFn: resume });
+   *
+   * async function parse(line) {
+   * 	await s.acquire();
+   *
+   * 	console.log(line);
+   *
+   * 	s.release();
+   * }
+   *
+   * rl.on('line', line => {
+   * 	parse(line).catch(console.error);
+   * });
+   * ```
+   *
+   */
+    constructor(maxConcurrency: number, { initFn, pauseFn, resumeFn, capacity, }?: {
+        initFn?: () => any;
+        pauseFn?: () => void;
+        resumeFn?: () => void;
+        capacity?: number;
+    });
+    /**
+   * Attempt to acquire a token from the semaphore, if one is available immediately. Otherwise, return undefined.
+   */
+    tryAcquire(): any | undefined;
+    /**
+     * Acquire a token from the semaphore, thus decrement the number of available execution slots. If initFn is not used then the return value of the function can be discarded.
+     */
+    acquire(signal?: AbortSignal): Promise<any>;
+    /**
+   * Release the semaphore, thus increment the number of free execution slots. If initFn is used then the token returned by acquire() should be given as an argument when calling this function.
+   */
+    release(token?: any): void;
+    /**
+   * Drains the semaphore and returns all the initialized tokens in an array. Draining is an ideal way to ensure there are no pending async tasks, for example before a process will terminate.
+   */
+    drain(): Promise<any[]>;
+    /**
+   * Returns the number of callers waiting on the semaphore, i.e. the number of pending promises.
+   *
+   * @returns The number of waiters in the waiting list.
+   */
+    pendingCount(): number;
+}
+/**
+ * Creates a rate limiter function that blocks with a promise whenever the rate limit is hit and resolves the promise once the call rate is within the limit set by rps. The second argument is optional.
+ *
+ * @param rps
+ * @param options.timeUnit The `timeUnit` is an optional argument setting the width of the rate limiting window in milliseconds.
+ *    The default `timeUnit` is 1000 ms, therefore making the rps argument act as requests per second limit.
+ * @param options.uniformDistribution  The `uniformDistribution` argument enforces a discrete uniform distribution over time,
+ *    instead of the default that allows hitting the function rps time and then pausing for timeWindow milliseconds. Setting
+ *    the `uniformDistribution` option is mainly useful in a situation where the flow of rate limit function calls is continuous
+ *    and and occuring faster than timeUnit (e.g. reading a file) and not enabling it would cause the maximum number of calls to
+ *    resolve immediately (thus exhaust the limit immediately) and therefore the next bunch calls would need to wait for timeWindow
+ *    milliseconds. However if the flow is sparse then this option may make the code run slower with no advantages.
+ *
+ * Examples:
+ *
+ * ```ts
+ * async function f() {
+ *   const lim = RateLimit(5); // rps
+ *
+ *   for (let i = 0; i < n; i++) {
+ *     await lim();
+ *     // ... do something async
+ *   }
+ * }
+ * ```
+ *
+ *
+ */
+declare function RateLimit(rps: number, { timeUnit, uniformDistribution, }?: {
+    timeUnit?: number;
+    uniformDistribution?: boolean;
+}): () => Promise<void>;
+
+type AsyncTaskId = string | number;
+interface CancelableAbilityOptions extends AbilityOptions {
+    asyncFeatures?: AsyncFeatures;
+    maxTaskConcurrency?: number;
+}
+declare class TaskAbortController extends AbortController {
+    id?: AsyncTaskId;
+    timeoutId?: any;
+    streamController?: ReadableStreamDefaultController;
+    parent: CancelableAbility;
+    constructor(parent: CancelableAbility);
+    abort(reason?: string | Error | CommonError, data?: any): void;
+    throwRejected(alreadyRejected?: boolean): true | undefined;
+}
+interface TaskAbortControllers {
+    [k: AsyncTaskId]: TaskAbortController | undefined;
+}
+interface TaskPromise<T = any> extends Promise<T> {
+    task?: TaskAbortController;
+}
+declare interface CancelableAbility {
+    _asyncFeatures?: number;
+    _maxTaskConcurrency: number | undefined;
+    [name: string]: any;
+}
+declare class CancelableAbility {
+    generateAsyncTaskId: (taskId?: AsyncTaskId, aborters?: TaskAbortControllers) => AsyncTaskId;
+    cleanMultiTaskAborter: (id: AsyncTaskId, aborters: TaskAbortControllers) => void;
+    __task_aborter: TaskAbortController | TaskAbortControllers | undefined;
+    __task_semaphore: Semaphore | undefined;
+    get maxTaskConcurrency(): number | undefined;
+    get semaphore(): Semaphore | undefined;
+    isAborted(taskId?: AsyncTaskId): boolean;
+    getRunningTask(taskId?: AsyncTaskId): TaskAbortController | undefined;
+    getRunningTaskCount(): number;
+    _generateAsyncTaskId(taskId?: AsyncTaskId, aborters?: TaskAbortControllers): AsyncTaskId;
+    $generateAsyncTaskId(taskId?: AsyncTaskId, aborters?: TaskAbortControllers): AsyncTaskId | undefined;
+    createAborter(params?: any, taskId?: AsyncTaskId, raiseError?: boolean): TaskAbortController;
+    $cleanMultiTaskAborter(id: AsyncTaskId, aborters: TaskAbortControllers): void;
+    cleanTaskAborter(aborter: TaskAbortController): void;
+    _cleanMultiTaskAborter(id: AsyncTaskId, aborters: TaskAbortControllers): void;
+    createTaskPromise<Output = any>(runTask: (params: Record<string, any>, aborter: TaskAbortController) => Promise<Output>, params: Record<string, any>, options?: {
+        taskId?: AsyncTaskId;
+        raiseError?: boolean;
+    }): TaskPromise<Output>;
+    runAsyncCancelableTask<Output = any>(params: Record<string, any> | undefined, runTask: (params: Record<string, any>, aborter: TaskAbortController) => Promise<Output>, options?: {
+        taskId?: AsyncTaskId;
+        raiseError?: boolean;
+    }): TaskPromise<Output>;
+    abort(reason?: string, data?: any): void;
+}
+type ToolFuncCancelableFn = (Tool: typeof ToolFunc, options?: CancelableAbilityOptions) => typeof ToolFunc;
+declare const makeToolFuncCancelable: ToolFuncCancelableFn;
+
 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> {
@@ -30,6 +248,7 @@ interface AIResult<TValue = any, TOptions = any> {
      * for stream mode
      */
     stop?: boolean;
+    taskId?: AsyncTaskId;
 }
 declare const AIMessageTypes: readonly ["human", "ai", "generic", "system", "tool"];
 type AIMessageType = typeof AIMessageTypes[number];
@@ -87,6 +306,7 @@ interface AIChatToolMessageParam extends AIChatMessageParamBase {
     tool_call_id: string;
     templateFormat?: string;
 }
+declare function messagesToText(messages: AIChatMessageParamBase[]): string;
 
 /**
  * Prompt Type
@@ -764,6 +984,8 @@ 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 function isWebStream(val: any): boolean;
+
 declare const RStreamErrCode = 600;
 declare const ResponseRStreamErrCode = 601;
 declare class ReadableStreamError extends BaseError {
@@ -780,29 +1002,6 @@ declare function getResponseErrorReadableStream(body?: ReadableStream<Uint8Array
  */
 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
@@ -827,29 +1026,6 @@ interface AIStreamParser<T = any, TOptions = any> {
  * @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
@@ -891,6 +1067,42 @@ declare function AIStream<T = any, TOptions = any>(response: Response, customPar
  */
 declare function readableFromAsyncIterable<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
 
+/**
+ * Configuration options and helper callback methods for stream lifecycle events.
+ * @interface
+ */
+interface StreamCallbacksAndOptions<I = any, O = any> {
+    /** `onStart`: Called once when the stream is initialized. */
+    onStart?: (controller: TransformStreamDefaultController) => Promise<void> | void;
+    /** `onToken`: Called for each tokenized message. */
+    onTransform?: (chunk: I, controller: TransformStreamDefaultController) => Promise<O | void> | O | void;
+    /** `onFinal`: Called once when the stream is closed with the final completion message. */
+    onFinal?: (controller: TransformStreamDefaultController) => Promise<void> | void;
+    onError?: (error: Error) => Promise<void> | void;
+}
+/**
+ * Creates a transform stream that 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.
+ * - `onTransform`: 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 [callbacks] - An object containing the callback functions.
+ * @return 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'),
+*   onTransform: async (chunk) => console.log('Token:',chunk),
+*   onFinal: async () => data.close()
+* };
+* const transformer = createCallbacksTransformer(callbacks);
+*/
+declare function createCallbacksTransformer<I = any, O = any>(cb: StreamCallbacksAndOptions<I, O> | undefined): TransformStream<I, O>;
+
 declare function uuid(ver?: 1 | 4 | 5, encode?: boolean): string;
 
 declare const base32768: typeof _base32768;
@@ -1044,7 +1256,7 @@ declare function parseJsJson(input: string, scope?: Record<string, any>): any;
 */
 declare function getKeysPath<TValue extends object>(value: TValue): string[];
 
-declare function createEndWithRepetitionDetector(repetitionThreshold: number): (value: string) => boolean;
+declare function createEndWithRepetitionDetector(repetitionThreshold: number): (value: string) => RegExpExecArray | null;
 
 /**
  * Loads a file from given paths, optionally searching for specific extensions.
@@ -1064,11 +1276,40 @@ declare function createEndWithRepetitionDetector(repetitionThreshold: number): (
 */
 declare function loadFileFromPaths(filename: string, searchPaths?: string[], extNames?: string[], options?: {
     filepath?: string;
+    exclude?: string[] | string;
 }): Buffer;
 declare function loadTextFromPaths(filename: string, searchPaths?: string[], extNames?: string[], options?: {
     encoding?: BufferEncoding;
     filepath?: string;
-} | BufferEncoding): string;
+} | BufferEncoding, exclude?: string[] | string): string;
+/**
+ * Recursively reads all filenames in the given directory or directories.
+ * Optionally filters the results using a file matching callback.
+ *
+ * @param dir - A single directory path or an array of directory paths to start the search from.
+ * @param isFileMatched - An optional callback that determines whether a file should be included in the result.
+ * @returns An array of file paths that match the criteria.
+ *
+ * @example
+* ```typescript
+* const files = readFilenamesRecursiveSync('/path/to/directory', (filepath) => filepath.endsWith('.js'));
+* console.log(files); // Outputs an array of JavaScript file paths.
+* ```
+*/
+declare function readFilenamesRecursiveSync(dir: string | string[], isFileMatched?: (filepath: string) => boolean): string[];
+/**
+ * Resolves the real file path, handling symbolic links.
+ *
+ * @param filepath - The file path to resolve.
+ * @returns The real file path.
+ *
+ * @example
+* ```typescript
+* const realPath = getRealFilepath('/path/to/symbolic/link');
+* console.log(realPath); // Outputs the resolved path.
+* ```
+*/
+declare function getRealFilepath(filepath: string): string;
 
 declare function registerYamlTag(tags: any): void;
 declare function parseYaml(content: string): any;
@@ -1130,4 +1371,72 @@ declare function jsonFilterToWhere(filter: JsonFilter | JsonFilter[], wrapKey?:
  */
 declare function matchUrlProtocol(name: string): string | undefined;
 
-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, matchUrlProtocol, parseFString, parseJsJson, parseYaml, reControlCharsRegex, readableFromAsyncIterable, registerYamlTag, sanitizeFilename, sanitizeFilepath, saveConfigFile, sortedValues, splitSentence, trimStartOfStreamHelper, truncTo, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };
+/**
+ * Formats a parameter size in bytes into a string with an appropriate scale (T, B, M, or K),
+ * optionally specifying the number of fractional digits to display.
+ *
+ * @param paramsSize The parameter size in bytes.
+ * @param fractionDigits The number of fractional digits to include in the formatted output. Default is 0 (no fractional digits).
+ * @returns A string representing the formatted parameter size with the appropriate scale unit and the specified number of fractional digits.
+ */
+declare function paramsSizeToScaleStr(paramsSize: number, fractionDigits?: number): string;
+/**
+ * Converts a formatted parameters size string (with units T, B, M, or K) back to its byte value.
+ *
+ * @param scale The formatted parameter size string (e.g., "1.23B", "456M", "789K", or "123").
+ * @returns The parameter size in bytes.
+ */
+declare function scaleStrToParamsSize(scale: string): number;
+
+declare function jsonToMarkdownStr(mem: any, options?: {
+    level?: number;
+    visiting?: Set<any>;
+    objectTag?: string;
+    arrayTag?: string;
+}): string;
+
+declare function toDateTime(date: Date | string | number): Date | undefined;
+declare function textToDate(date: string, format?: string): Date;
+declare function dateToText(date: Date, format?: string): string;
+
+/**
+ * Represents a set of integers using a bit field.
+ * Each bit in the bit field represents an integer starting from 0,
+ * where the flag value 0 represents the 0th bit, 1 represents the 1st bit, and so on.
+ */
+declare class IntSet {
+    private bitField;
+    static has(bitField: number, flag: number): boolean;
+    static add(bitField: number, flag: number): number;
+    static delete(bitField: number, flag: number): number;
+    constructor(bitField?: number);
+    /**
+     * Adds an element to the set.
+     *
+     * @param flag - The flag value representing the bit position to set.
+     *              Note: the flag value 0 represents the 0th bit, and so on.
+     */
+    add(flag: number): this;
+    /**
+     * Removes an element from the set.
+     *
+     * @param flag - The flag value representing the bit position to set. 0 represents the 0th bit
+     */
+    delete(flag: number): this;
+    /**
+     * Determines whether an element is in the set.
+     *
+     * @param flag - The flag value representing the bit position to set. 0 represents the 0th bit
+     * @returns true if the element is in the set; otherwise, false.
+     */
+    has(flag: number): boolean;
+    /**
+     * Clears all elements from the set.
+     */
+    clear(): this;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): number;
+}
+
+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 AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, AsyncFeatures, type AsyncTaskId, BaseError, CancelableAbility, type CancelableAbilityOptions, CommonError, DefaultAsyncSemaphoreCapacity, 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, IntSet, type JsonFilter, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, RateLimit, ReadableStreamError, ResponseRStreamErrCode, type SanitizeFilenameOptions, Semaphore, type StreamCallbacksAndOptions, TaskAbortController, type TaskAbortControllers, type TaskPromise, ToolFunc, WindowsReservedNameRegex, XXHashAlgorithm, backendEventable, base32768, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, dateToText, defaultTemplateFormat, expandEnv, expandObjEnv, extNameLevel, filenameReservedRegex, getAllEnumKeys, getConfigFileNames, getConfigs, getKeysPath, getMultiLevelExtname, getRealFilepath, getResponseErrorReadableStream, parse as hfParse, tokenize as hfTokenize, interpolateEnv, interpolateFString, interpolateGolangTemplate, isModelNameMatched, isValidFilename, isValidFilepath, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadFileFromPaths, loadTextFromPaths, makeToolFuncCancelable, matchUrlProtocol, messagesToText, paramsSizeToScaleStr, parseFString, parseJsJson, parseYaml, reControlCharsRegex, readFilenamesRecursiveSync, readableFromAsyncIterable, registerYamlTag, sanitizeFilename, sanitizeFilepath, saveConfigFile, scaleStrToParamsSize, sortedValues, splitSentence, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };