@isdk/ai-tool 0.3.0 → 0.5.0

package/dist/index.d.mts

@@ -1,15 +1,17 @@
 import * as custom_ability from 'custom-ability';
-import { AbilityOptions } from 'custom-ability';
 export { createAbilityInjector } from 'custom-ability';
 export { toRegExp } from 'util-ex';
-import { A as AsyncFeatures, T as ToolFunc, a as AIModelNameRules } from './index-BC3GQn6-.mjs';
-export { e as AIModelNameRule, d as AIModelNameRuleFn, c as ActionName, b as ActionNames, k as AsyncFeatureBits, p as BaseFunc, B as BaseFuncItem, C as ClientFuncItem, u as ClientToolFuncSchema, t as ClientTools, J as EventClient, I as EventClientFuncParams, M as EventServer, L as EventServerFuncParams, E as EventToolFunc, o as FuncItem, l as FuncParam, F as FuncParamType, m as FuncParams, q as Funcs, P as PASSING_SCORE, f as RemoteFuncItem, R as RemoteToolFuncSchema, O as ResClientFuncParams, Q as ResClientTools, U as ResServerFuncParams, V as ResServerTools, g as SSEChannel, S as SSEChannelAlreadyClosedErrCode, w as ServerFuncItem, v as ServerFuncParams, y as ServerToolFuncSchema, x as ServerTools, n as TFunc, i as ToolAsyncCancelableBit, h as ToolAsyncMultiTaskBit, j as ToolAsyncPriorityBit, r as ToolFuncPackage, s as ToolFuncSchema, _ as _lrucache, G as createLRUCache, D as event, K as eventClient, N as eventServer, H as lrucache, z as registerCoreTools } from './index-BC3GQn6-.mjs';
-import { CommonError, BaseError } from '@isdk/common-error';
+import { A as AsyncTaskId, a as AIModelNameRules } from './index-Br-4ZYgE.mjs';
+export { e as AIModelNameRule, d as AIModelNameRuleFn, c as ActionName, b as ActionNames, s as AsyncFeatureBits, t as AsyncFeatures, J as BaseFunc, H as BaseFuncItem, n as BinarySemaphore, i as BinarySemaphoreAcquireOptions, B as BinarySemaphoreOptions, j as BinarySemaphoreReleaseOptions, k as BinarySemaphoreReleaserFunc, x as CancelableAbility, C as CancelableAbilityOptions, O as ClientFuncItem, U as ClientToolFuncSchema, Q as ClientTools, D as DefaultAsyncSemaphoreCapacity, a5 as EventClient, a4 as EventClientFuncParams, a8 as EventServer, a7 as EventServerFuncParams, _ as EventToolFunc, I as FuncItem, z as FuncParam, F as FuncParamType, E as FuncParams, K as Funcs, P as PASSING_SCORE, p as RateLimit, f as RemoteFuncItem, R as RemoteToolFuncSchema, aa as ResClientFuncParams, ab as ResClientTools, ac as ResServerFuncParams, ad as ResServerTools, g as SSEChannel, S as SSEChannelAlreadyClosedErrCode, a0 as SecondaryCache, o as Semaphore, h as SemaphoreIsReadyFuncType, l as SemaphoreOptions, m as SemaphoreTaskItem, W as ServerFuncItem, V as ServerFuncParams, Y as ServerToolFuncSchema, X as ServerTools, G as TFunc, u as TaskAbortController, v as TaskAbortControllers, w as TaskPromise, q as ToolAsyncCancelableBit, T as ToolAsyncMultiTaskBit, r as ToolAsyncPriorityBit, M as ToolFunc, L as ToolFuncPackage, N as ToolFuncSchema, a1 as _lrucache, a2 as createLRUCache, $ as event, a6 as eventClient, a9 as eventServer, a3 as lrucache, y as makeToolFuncCancelable, Z as registerCoreTools } from './index-Br-4ZYgE.mjs';
+import { BaseError } from '@isdk/common-error';
 export { AbortError, AbortErrorCode, AlreadyExistsError, AlreadyExistsErrorCode, BaseError, CommonError, ErrorCode, InternalErrorCode, NotFoundError, NotFoundErrorCode, NotImplementationError, NotImplementedErrorCode, createError, throwError } from '@isdk/common-error';
 import { BaseFactory } from 'custom-factory';
-import { Event } from 'events-ex';
+import { Event, EventEmitter } from 'events-ex';
+export { EventEmitter, states as EventStates, eventable, wrapEventEmitter } from 'events-ex';
 import * as _base32768 from 'base32768';
+import { IDataType } from 'hash-wasm';
 import * as fs from 'fs';
+import { ParseOptions, DocumentOptions, SchemaOptions, ToJSOptions, CreateNodeOptions, ToStringOptions } from 'yaml';
 import _memoize, { Options } from 'memoizee';
 export { f as findPort } from './find-port-qS1CZ9c-.mjs';
 import { PreTrainedTokenizer } from '@xenova/transformers';
@@ -18,225 +20,10 @@ export { canonicalize } from 'json-canonicalize';
 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';
+export { LRUCache } from 'secondary-cache';
 import 'property-manager';
-import 'secondary-cache';
 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", "function_call", "abort", "error", "other", null];
 type AITextGenerationFinishReason = typeof AITextGenerationFinishReasons[number];
 interface AIResult<TValue = any, TOptions = any> {
@@ -260,12 +47,14 @@ declare const AIMessageTypes: readonly ["human", "ai", "generic", "system", "too
 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;
+type AIChatMessageParam = AIChatMessageParamBase | AIChatSystemMessageParam | AIChatUserMessageParam | AIChatAssistantMessageParam | AIChatToolMessageParam;
 interface AIChatMessageParamBase {
     role: string;
     toRole?: string | string[] | Record<string, Partial<AIChatMessageParam>>;
     replies?: Record<string, Partial<AIChatMessageParam>>;
     private?: boolean;
+    tools?: Record<string, string>;
+    thinking?: string;
     [name: string]: any;
 }
 interface AIChatSystemMessageParam extends AIChatMessageParamBase {
@@ -315,6 +104,32 @@ interface AIChatToolMessageParam extends AIChatMessageParamBase {
     tool_call_id: string;
     templateFormat?: string;
 }
+interface AIChatToolParam {
+    type: string;
+    [key: string]: any;
+}
+interface AIChatToolFuncParam extends AIChatToolParam {
+    type: 'function';
+    function: AIChatToolFunc;
+}
+interface AIChatToolFunc {
+    name: string;
+    description?: string;
+    parameters?: any;
+    strict?: boolean;
+}
+type AIChatToolChoiceParam = 'auto' | 'none' | 'required' | AIChatToolChoiceObject;
+interface AIChatToolChoiceObject {
+    type: string;
+    [key: string]: any;
+}
+interface AIChatToolChoiceFuncObject extends AIChatToolChoiceObject {
+    type: 'function';
+    function: AIChatToolTypeObject;
+}
+interface AIChatToolTypeObject {
+    name: string;
+}
 declare function messagesToText(messages: AIChatMessageParamBase[]): string;
 
 /**
@@ -461,6 +276,7 @@ declare const TOKEN_TYPES: Readonly<{
     Text: "Text";
     NumericLiteral: "NumericLiteral";
     BooleanLiteral: "BooleanLiteral";
+    NullLiteral: "NullLiteral";
     StringLiteral: "StringLiteral";
     Identifier: "Identifier";
     Equals: "Equals";
@@ -746,10 +562,12 @@ declare function tojson(value: any, indent?: number | {
     indent?: number;
     depth?: number;
 }, depth?: number): string;
+declare function join(value: any, separator?: string): any;
 declare const builtins: {
     randomInt: typeof randomInt;
     select: typeof select;
     tojson: typeof tojson;
+    join: typeof join;
 };
 
 /**
@@ -778,7 +596,7 @@ declare class Template {
      * @param {string} template The template string
      */
     constructor(template: string, options?: PreprocessOptions);
-    render(items: Record<string, unknown>): string;
+    render(items?: Record<string, unknown>): string;
 }
 
 declare class HfPromptTemplate extends PromptTemplate {
@@ -830,6 +648,13 @@ declare class GolangPromptTemplate extends PromptTemplate {
     _format(data: Record<string, any>): string;
 }
 
+declare class EnvPromptTemplate extends PromptTemplate {
+    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean;
+    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 {
     /**
@@ -875,7 +700,8 @@ declare class FewShotPromptTemplate<T = any> extends PromptTemplate {
  */
 declare function interpolateGolangTemplate(str: string, variables: Record<string, any>, initVars?: boolean): string;
 
-declare function interpolateEnv(value: string, processEnv: any, parsed: any): any;
+declare function getEnvVairables(value: string): string[];
+declare function interpolateEnv(value: string, processEnv: Record<string, any>, parsed?: Record<string, 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.
@@ -1051,7 +877,22 @@ 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 function getEventableClass(Backend: any): {
+    new (): {
+        name: string;
+        _events: any;
+        readonly emitter: any;
+        on(eventName: string, listener: EventListenerFn): EventEmitter | void;
+        once(eventName: string, listener: EventListenerFn): EventEmitter | void;
+        off(type: string, listener: EventListenerFn): EventEmitter;
+        emit(eventName: string, ...args: any[]): any;
+        emitError(err: any, ...args: any[]): any;
+        emitAsync(eventName: string, ...args: any[]): Promise<any>;
+    };
+    _emitter: any;
+    readonly emitter: any;
+};
+declare const backendEventable: <T extends Function | (new (...args: any[]) => any)>(targetClass?: T | undefined, options?: custom_ability.AbilityOptions) => T & typeof getEventableClass & (T extends new (...args: any[]) => any ? InstanceType<T> : T);
 
 declare function isWebStream(val: any): val is ReadableStream<any> | WritableStream<any>;
 
@@ -1174,10 +1015,6 @@ declare function createCallbacksTransformer<I = any, O = any>(cb: StreamCallback
 
 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 HashAlgorithm {
     md5 = 1,
     sha1 = 2,
@@ -1191,15 +1028,22 @@ declare enum HashAlgorithm {
     xxhash32 = 112,
     xxhash128 = 113
 }
+
+declare function xxhash32(value: string | object, radix?: number): string;
+declare function xxhash64(value: string | object, radix?: number): string;
 type HashValue = string | ArrayBuffer | Buffer;
 declare function xxhash(value: HashValue, hashAlgo?: HashAlgorithm, seed?: number): Uint8Array;
 declare function xxhashAsStr(value: string | Uint8Array, hashAlgo?: HashAlgorithm, seed?: number): string;
+
+declare const base32768: typeof _base32768;
+
 interface HashAlgoParams {
     hashAlgo?: HashAlgorithm;
     seed?: number;
     outputType?: 'hex' | 'binary' | 'string';
 }
-declare function hashStream(stream: ReadableStream, { hashAlgo, seed, outputType }?: HashAlgoParams): Promise<string | Uint8Array>;
+declare function hashStream(stream: ReadableStream, { hashAlgo, seed, outputType }?: HashAlgoParams): Promise<string | Uint8Array<ArrayBufferLike>>;
+declare function hash(value: IDataType, { hashAlgo, seed, outputType }?: HashAlgoParams): Promise<string | Uint8Array<ArrayBufferLike>>;
 
 /**
  * Regular expression pattern for reserved characters in a filename.
@@ -1377,7 +1221,7 @@ declare function loadFileFromPaths(filename: string, searchPaths?: string[], ext
     filepath?: string;
     exclude?: string[] | string;
     signal?: AbortSignal;
-}): Buffer;
+}): Buffer<ArrayBufferLike>;
 declare function loadTextFromPaths(filename: string, searchPaths?: string[], extNames?: string[], options?: {
     encoding?: BufferEncoding;
     filepath?: string;
@@ -1417,7 +1261,7 @@ declare function readFilenamesRecursiveSync(dir: string | string[], options?: {
 * ```
 */
 declare function getRealFilepath(filepath: string): string;
-declare function hashFile(filepath: string, options?: HashAlgoParams): Promise<string | Uint8Array>;
+declare function hashFile(filepath: string, options?: HashAlgoParams): Promise<string | Uint8Array<ArrayBufferLike>>;
 interface IFileMetaInfo {
     name: string;
     mtime: Date;
@@ -1432,8 +1276,8 @@ declare function getHashAlgoBySize(size: number): HashAlgorithm;
 declare function detectCharset(content: Buffer | string, options?: any): string;
 
 declare function registerYamlTag(tags: any): void;
-declare function parseYaml(content: string): any;
-declare function stringifyYaml(content: any): string;
+declare function parseYaml(content: string, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
+declare function stringifyYaml(content: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions): string;
 
 interface ConfigFilesFilter {
     after?: {
@@ -1560,6 +1404,58 @@ declare class IntSet {
     toJSON(): number;
 }
 
+/**
+ * An asynchronous signal gate that blocks operations until a signal is emitted.
+ * This class allows multiple awaiters to wait for a signal and resolves all pending promises with the emitted value.
+ * The gate can be reset to reuse for subsequent signals.
+ *
+ * @example
+ *
+ * ```typescript
+ * // Default type is void, can call signal() without parameters
+ * const gate = new SignalGate();
+ * gate.signal(); // No parameters required
+ *
+ * // Example with explicit type
+ * const valueGate = new SignalGate<number>();
+ * valueGate.signal(42); // Must provide a number value
+ * ```
+ */
+declare class SignalGate<T = void> {
+    protected _isSignaled: boolean;
+    protected _signalValue: T | undefined;
+    protected waitQueue: Array<{
+        resolve: (value: T) => void;
+        reject: (error: any) => void;
+    }>;
+    get signaled(): boolean;
+    /**
+     * Emits the signal with an optional value, resolving all pending {@link wait} promises.
+     * Subsequent calls have no effect until {@link reset} is called.
+     *
+     * @param value The value to emit with the signal (only required if T is not void).
+     */
+    signal(value?: T): void;
+    /**
+     * Resets the gate to its initial state, allowing a new signal to be emitted.
+     */
+    reset(): void;
+    /**
+     * Aborts all pending waits, rejecting their promises with an error.
+     * This does **not** reset the signal state (the gate remains signaled or unsignaled).
+     *
+     * @param reason The reason for aborting the waits.
+     */
+    abort(reason?: any): void;
+    /**
+     * Returns a promise that resolves with the emitted signal value.
+     * If called after the signal has been emitted, resolves immediately with the stored value.
+     *
+     * @returns A promise resolving to the signal value (type T).
+     */
+    wait(): Promise<T>;
+}
+
 /**
  * Counts the number of matches for a given regular expression in a specified string.
  * This function ensures that the regular expression is used globally by adding the 'g' flag,
@@ -1592,6 +1488,7 @@ interface ParseObjectArgumentOptions {
     ignoreIndexNamed?: boolean;
     preserveUnresolvedName?: boolean;
     skipExpression?: boolean;
+    raiseError?: boolean;
 }
 /**
  * Asynchronously parses a string of object arguments into an actual object.
@@ -1633,11 +1530,18 @@ interface ParseObjectArgumentOptions {
  * ```
  */
 declare function parseObjectArguments(argsStr: string, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<any>;
+declare function ObjectArgsToArgsInfo(args: any): {
+    args: any[];
+    kvArgs?: Record<string, any>;
+};
 declare function simplifyObjectArguments(args: any): any;
 declare function parseObjectArgumentInfos(args: ArgInfo[], scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<any>;
 declare function ChoiceArgProcessor(argInfo: ArgInfo, _ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): string | undefined;
 declare function TemplateArgProcessor([isNamedArg, arg]: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string | undefined>;
 declare function AIArgProcessor(argInfo: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string | undefined>;
+declare function isQuoted(s: string): boolean;
+declare function isStrWrapped(s: string, pairs?: string[]): boolean;
+declare function ensureQuoted(s: string, quoteChar?: string): string;
 declare function quoteStr(str: string): string;
 declare function parseObjectArgInfo(argInfo: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string>;
 /**
@@ -1659,7 +1563,7 @@ declare function parseObjectArgumentsAsArgInfos(argsStr: string, scope?: Record<
 declare function parseCommand(commandStr: string, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<{
     command: string;
     args?: Record<string, any>;
-}>;
+} | undefined>;
 interface ReplacePlacehoderOptions {
     startChar?: string | string[];
     endChar?: string | string[];
@@ -1745,6 +1649,14 @@ declare function isSubdirectory(parentDir: string, childDir: string): boolean;
  * hasDirectoryIn('parentdir/subdir', ['parentdir', 'otherdir']); // true
  */
 declare function hasDirectoryIn(dir: string, dirs?: string[]): boolean | undefined;
+/**
+ * Assigns directories from the source array to the destination array if they do not already exist in the destination.
+ *
+ * @param dest - The destination array to which new directories will be added.
+ * @param src - The source array containing directories to be assigned to the destination.
+ * @returns The updated destination array with newly assigned directories from the source.
+ */
+declare function assignDirs(dest: string[], src: string[]): string[];
 
 declare function isRegExp(value: any): boolean;
 
@@ -1861,8 +1773,8 @@ type Includes<Value extends readonly any[], Item> =
 @category Utilities
 */
 type IsEqual<A, B> =
-	(<G>() => G extends A ? 1 : 2) extends
-	(<G>() => G extends B ? 1 : 2)
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
 		? true
 		: false;
 
@@ -2023,4 +1935,60 @@ declare class YamlTypeBaseObject {
 }
 declare function createYamlObjectTag(tag: string, BaseObject: typeof YamlTypeBaseObject): any;
 
-export { AIArgProcessor, type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatToolMessageParam, type AIChatUserMessageParam, type AIChoiceConfig, type AIMessageType, AIMessageTypes, AIModelNameRules, type AIResult, AIStream, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, AsyncFeatures, type AsyncTaskId, CancelableAbility, type CancelableAbilityOptions, ChoiceArgProcessor, 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, type HashAlgoParams, HashAlgorithm, HfPromptTemplate, type IFileMetaInfo, type IReadTextFileChunksOptions, type ITruncateToTokenLimitOptions, IntSet, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, type ParseObjectArgumentOptions, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, RateLimit, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, type SanitizeFilenameOptions, type SectionStringOptions, Semaphore, type SplitSentenceOptions, type StreamCallbacksAndOptions, TaskAbortController, type TaskAbortControllers, type TaskPromise, TemplateArgProcessor, ToolFunc, WindowsReservedNameRegex, YamlTypeBaseObject, backendEventable, base32768, completeSentences, concatText, countLLMTokens, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, createYamlObjectTag, dateToText, decodeCharset, defaultTemplateFormat, detectCharset, encodeLLMTokens, expandEnv, expandObjEnv, extNameLevel, fileIsExists, filenameReservedRegex, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, getAllEnumKeys, getConfigFileNames, getConfigs, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getMultiLevelExtname, getPackageDir, getRealFilepath, getResponseErrorReadableStream, hasDirectoryIn, hashFile, hashStream, parse as hfParse, tokenize as hfTokenize, interpolateEnv, interpolateFString, interpolateGolangTemplate, isLangUsingSpaces, isListItemString, isModelNameMatched, isPunctuationChar, isRegExp, isSectionString, isSentenceEnding, isSepLineString, isSubdirectory, isTitleString, isValidFilename, isValidFilepath, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadFileFromPaths, loadTextFromPaths, makeToolFuncCancelable, matchUrlProtocol, memoize, messagesToText, paramsSizeToScaleStr, parseCommand, parseFString, parseJsJson, parseJsJsonSimpleSync, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, parseYaml, quoteStr, reControlCharsRegex, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, registerYamlTag, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, sanitizeFilename, sanitizeFilepath, saveConfigFile, scaleStrToParamsSize, simplifyObjectArguments, sortedValues, splitChunks, splitParagraph, splitSentence, stringifyYaml, stripConsoleColor, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, truncateByToken, truncateToTokenLimit, truncateToTokenLimitEx, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };
+/**
+ * Compares two strings to check if they are the same.
+ *
+ * This function first checks if the strings have the same length. If they do, it compares the strings character by character.
+ * If the strings are not the same length, it returns false immediately.
+ *
+ * @param str1 - The first string to compare.
+ * @param str2 - The second string to compare.
+ * @returns A boolean indicating whether the two strings are the same.
+ */
+declare function isSameString(str1: string, str2: string): boolean;
+
+declare const DEFAULT_CONFIG_NAME = ".ai";
+type Config = any;
+declare function loadConfigFile(filename: string, searchPaths?: string[]): any;
+declare function expandConfig(config: any, defaultConfig: any): any;
+declare function loadConfig(filename: string, config: Config): any;
+declare function loadAIConfig(config: Config): any;
+declare function getXDGConfigs(config: Config): {
+    XDG_CONFIG_HOME: any;
+    XDG_DATA_HOME: any;
+    XDG_CACHE_HOME: any;
+    XDG_BIN_HOME: string;
+};
+declare function expandPath(path: string, config?: any): any;
+
+/**
+ * @callback BeforeShutdownListener
+ * @param {string} [signalOrEvent] The exit signal or event name received on the process.
+ */
+type BeforeShutdownListener = (signalOrEvent: string) => Promise<void> | void;
+/**
+ * System signals the app will listen to initiate shutdown.
+ * @const {string[]}
+ *
+ * SIGINT, a.k.a Ctrl + C, and SIGTERM by default
+ */
+declare const SHUTDOWN_SIGNALS: string[];
+/**
+ * Main process shutdown handler. Will invoke every previously registered async shutdown listener
+ * in the queue and exit with a code of `0`. Any `Promise` rejections from any listener will
+ * be logged out as a warning, but won't prevent other callbacks from executing.
+ * @param {string} signalOrEvent The exit signal or event name received on the process, defaults to shutdown.
+ * @param {number|string|null} exitCode The optional exit code, defaults to 0.
+ */
+declare function shutdown(signalOrEvent?: string | number, exitCode?: number | string | null): Promise<undefined>;
+/**
+ * Registers a new shutdown listener to be invoked before exiting
+ * the main process. Listener handlers are guaranteed to be called in the order
+ * they were registered.
+ * @param {BeforeShutdownListener} listener The shutdown listener to register.
+ * @returns {BeforeShutdownListener} Echoes back the supplied `listener`.
+ */
+declare function beforeShutdown(listener: BeforeShutdownListener): BeforeShutdownListener | undefined;
+declare function initShutdown(): void;
+
+export { AIArgProcessor, type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatToolChoiceFuncObject, type AIChatToolChoiceObject, type AIChatToolChoiceParam, type AIChatToolFunc, type AIChatToolFuncParam, type AIChatToolMessageParam, type AIChatToolParam, type AIChatToolTypeObject, type AIChatUserMessageParam, type AIChoiceConfig, type AIMessageType, AIMessageTypes, AIModelNameRules, type AIResult, AIStream, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, AsyncTaskId, type BeforeShutdownListener, ChoiceArgProcessor, DEFAULT_CONFIG_NAME, type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, EnvPromptTemplate, 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, type HashAlgoParams, HashAlgorithm, HfPromptTemplate, type IFileMetaInfo, type IReadTextFileChunksOptions, type ITruncateToTokenLimitOptions, IntSet, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, ObjectArgsToArgsInfo, type ParseObjectArgumentOptions, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, SHUTDOWN_SIGNALS, type SanitizeFilenameOptions, type SectionStringOptions, SignalGate, type SplitSentenceOptions, type StreamCallbacksAndOptions, TemplateArgProcessor, WindowsReservedNameRegex, YamlTypeBaseObject, assignDirs, backendEventable, base32768, beforeShutdown, completeSentences, concatText, countLLMTokens, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, createYamlObjectTag, dateToText, decodeCharset, defaultTemplateFormat, detectCharset, encodeLLMTokens, ensureQuoted, expandConfig, expandEnv, expandObjEnv, expandPath, extNameLevel, fileIsExists, filenameReservedRegex, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, getAllEnumKeys, getConfigFileNames, getConfigs, getEnvVairables, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getMultiLevelExtname, getPackageDir, getRealFilepath, getResponseErrorReadableStream, getXDGConfigs, hasDirectoryIn, hash, hashFile, hashStream, parse as hfParse, tokenize as hfTokenize, initShutdown, interpolateEnv, interpolateFString, interpolateGolangTemplate, isLangUsingSpaces, isListItemString, isModelNameMatched, isPunctuationChar, isQuoted, isRegExp, isSameString, isSectionString, isSentenceEnding, isSepLineString, isStrWrapped, isSubdirectory, isTitleString, isValidFilename, isValidFilepath, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadAIConfig, loadConfig, loadConfigFile, loadFileFromPaths, loadTextFromPaths, matchUrlProtocol, memoize, messagesToText, paramsSizeToScaleStr, parseCommand, parseFString, parseJsJson, parseJsJsonSimpleSync, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, parseYaml, quoteStr, reControlCharsRegex, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, registerYamlTag, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, sanitizeFilename, sanitizeFilepath, saveConfigFile, scaleStrToParamsSize, shutdown, simplifyObjectArguments, sortedValues, splitChunks, splitParagraph, splitSentence, stringifyYaml, stripConsoleColor, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, truncateByToken, truncateToTokenLimit, truncateToTokenLimitEx, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };