@isdk/ai-tool 0.4.0 → 0.5.0

package/dist/index-Br-4ZYgE.d.ts

@@ -0,0 +1,892 @@
+import { EventEmitter, Event } from 'events-ex';
+import { AdvancePropertyManager } from 'property-manager';
+import { AbilityOptions } from 'custom-ability';
+import * as _isdk_common_error from '@isdk/common-error';
+import { CommonError } from '@isdk/common-error';
+import { Cache, ICacheOptions } from 'secondary-cache';
+import { IncomingMessage, ServerResponse } from 'http';
+
+type FuncParamType = string;
+interface FuncParam {
+    name?: string;
+    type?: FuncParamType;
+    required?: boolean;
+    description?: string;
+    asyncFeatures?: number;
+    depends?: {
+        [name: string]: ToolFunc;
+    };
+}
+interface FuncParams {
+    [name: string]: FuncParam | FuncParamType;
+}
+type TFunc = (this: ToolFunc, ...params: any[]) => any;
+interface BaseFuncItem {
+    name?: string;
+    params?: FuncParams | FuncParam[];
+    result?: string;
+    scope?: any;
+    tags?: string | string[];
+    setup?: (this: ToolFunc, options?: FuncItem) => void;
+    isApi?: boolean;
+    stream?: boolean;
+}
+interface FuncItem extends BaseFuncItem {
+    func?: TFunc;
+}
+interface BaseFunc extends BaseFuncItem {
+    func(...params: any): any;
+}
+interface Funcs {
+    [name: string]: ToolFunc;
+}
+interface ToolFuncPackage {
+    name: string;
+    register: (data?: any) => void;
+    unregister?: () => void;
+}
+declare interface ToolFunc extends BaseFunc {
+    [name: string]: any;
+}
+declare class ToolFunc extends AdvancePropertyManager {
+    static items: Funcs;
+    static dataPath: string;
+    static get(name: string): ToolFunc;
+    static list(): Funcs;
+    static getByTag(tagName: string): ToolFunc | undefined;
+    static getAllByTag(tagName: string): ToolFunc[];
+    static hasAsyncFeature(feature: AsyncFeatureBits): boolean;
+    static run(name: string, params?: any): Promise<any>;
+    static runSync(name: string, params?: any): any;
+    static getFunc(name: string): any;
+    static runWithPos(name: string, ...params: any[]): Promise<any>;
+    static runWithPosSync(name: string, ...params: any[]): any;
+    static getFuncWithPos(name: string): any;
+    static register(name: string, options: FuncItem): boolean | ToolFunc;
+    static register(func: Function, options: FuncItem): boolean | ToolFunc;
+    static register(name: string | ToolFunc | Function | FuncItem, options?: FuncItem): boolean | ToolFunc;
+    static unregister(name: string): ToolFunc | undefined;
+    constructor(name: string | Function | FuncItem, options?: FuncItem | any);
+    register(): boolean | ToolFunc;
+    unregister(): any;
+    arr2ObjParams(params: any[]): any[];
+    obj2ArrParams(params?: any): any[];
+    runSync(params?: any): any;
+    run(params?: any): Promise<any>;
+    runAs(name: string, params?: any): Promise<any>;
+    runAsSync(name: string, params?: any): any;
+    getFunc(name?: string): any;
+    runWithPosSync(...params: any[]): any;
+    runWithPosAsSync(name: string, ...params: any[]): any;
+    runWithPos(...params: any[]): Promise<any>;
+    runWithPosAs(name: string, ...params: any[]): Promise<any>;
+    getFuncWithPos(name?: string): any;
+    hasAsyncFeature(feature: AsyncFeatureBits): boolean;
+    isStream(params: any): boolean | undefined;
+}
+declare const ToolFuncSchema: {
+    name: {
+        type: string;
+    };
+    description: {
+        type: string;
+    };
+    func: {
+        type: string;
+        assign(value: Function | string, dest: ToolFunc, src?: ToolFunc, name?: string, options?: any): string | Function;
+    };
+    params: {
+        type: string;
+    };
+    result: {
+        type: string;
+    };
+    setup: {
+        type: string;
+    };
+    depends: {
+        type: string;
+        exported: boolean;
+    };
+    tags: {
+        type: string[];
+    };
+    isApi: {
+        type: string;
+    };
+    stream: {
+        type: string;
+    };
+    asyncFeatures: {
+        type: string;
+    };
+};
+
+declare const PASSING_SCORE = 0.618;
+declare const ActionNames: readonly ["get", "post", "put", "delete", "patch", "list", "res"];
+type ActionName = typeof ActionNames[number];
+type AIModelNameRuleFn = (name: string) => string | RegExpExecArray | undefined;
+type AIModelNameRule = string | RegExp | AIModelNameRuleFn;
+type AIModelNameRules = AIModelNameRule | AIModelNameRule[];
+declare const RemoteToolFuncSchema: {
+    apiRoot: {
+        type: string;
+        get(this: any): any;
+        set(this: any, value: string): void;
+    };
+    action: {
+        type: string;
+        assign(value: ActionName, dest: any, src?: any, name?: string, options?: any): "get" | "post" | "put" | "delete" | "patch" | "list" | "res";
+    };
+    fetchOptions: {
+        type: string;
+    };
+    allowExportFunc: {
+        type: string;
+    };
+};
+interface RemoteFuncItem extends BaseFuncItem {
+    apiRoot?: string;
+    action?: ActionName;
+    fetchOptions?: any;
+}
+
+declare class Deque<T = any> extends Array<T> {
+    private _capacity;
+    private _length;
+    private _front;
+    private _disableAutoResize?;
+    constructor(capacity?: number | T[], disableAutoResize?: boolean);
+    push(item: T): number;
+    unshift(item: T): number;
+    /**
+     * Removes and returns the element at the back of the deque.
+     *
+     * @param skipNull When `true`, skips trailing `null`/`undefined` values until a valid element is found or all elements are processed.
+     * @returns The removed element, or `undefined` if the deque is empty or all elements are skipped.
+     *
+     * @example
+     * // Normal pop without skipping
+     * const deque = new Deque([1, 2, 3]);
+     * deque.pop(); // 3
+     *
+     * @example
+     * // Skipping null values
+     * const nullDeque = new Deque([null, 4, null]);
+     * nullDeque.pop(true); // 4
+     * nullDeque.pop(true); // undefined (skipped remaining nulls)
+     *
+     * @example
+     * // Mixed elements with skip
+     * const mixedDeque = new Deque([5, null, 6, null]);
+     * mixedDeque.pop(true); // 6
+     * mixedDeque.pop(false); // null (explicitly not skipping)
+     */
+    pop(skipNull?: boolean): T | undefined;
+    /**
+     * Removes and returns the element at the front of the deque.
+     *
+     * @param skipNull When `true`, skips leading `null`/`undefined` values until a valid element is found or all elements are processed.
+     * @returns The removed element, or `undefined` if the deque is empty or all elements are skipped.
+     *
+     * @example
+     * // Normal shift without skipping
+     * const deque = new Deque([1, 2, 3]);
+     * deque.shift(); // 1
+     *
+     * @example
+     * // Skipping null values
+     * const nullDeque = new Deque([null, 4, null]);
+     * nullDeque.shift(true); // 4
+     * nullDeque.shift(true); // undefined (skipped remaining nulls)
+     *
+     * @example
+     * // Mixed elements with skip
+     * const mixedDeque = new Deque([null, 5, null, 6]);
+     * mixedDeque.shift(true); // 5
+     * mixedDeque.shift(false); // null (explicitly not skipping)
+     */
+    shift(skipNull?: boolean): T | undefined;
+    /**
+     * Gets the number of elements in the deque.
+     *
+     * @returns The current count of elements in the deque.
+     *
+     * @example
+     * const deque = new Deque([1, 2, 3]);
+     * console.log(deque.size); // 3
+     *
+     * @important
+     * Do NOT use the native `Array.length` property. The Deque implementation uses a circular buffer with capacity management, so the native `length` reflects the underlying array capacity, not the actual element count. Always use `size` to get the correct element count.
+     */
+    get size(): number;
+    get(index: number): T | undefined;
+    peekBack(): T | undefined;
+    peekFront(): T | undefined;
+    clear(): void;
+    isEmpty(): boolean;
+    /**
+     * Removes the element at the specified index.
+     * @param index Logical index position (0 represents the front, length-1 represents the back)
+     * @returns The removed element
+     */
+    removeAt(index: number): T | undefined;
+    private checkCapacity;
+    private resizeTo;
+}
+
+declare const DefaultAsyncSemaphoreCapacity = 32;
+type SemaphoreIsReadyFuncType = () => Promise<boolean> | boolean;
+interface BinarySemaphoreOptions {
+    initFn?: () => any;
+    pauseFn?: () => void;
+    resumeFn?: () => void;
+    capacity?: number;
+}
+interface BinarySemaphoreAcquireOptions {
+    signal?: AbortSignal;
+    [n: string]: any;
+}
+interface BinarySemaphoreReleaseOptions {
+    token?: any;
+    [n: string]: any;
+}
+interface BinarySemaphoreReleaserFunc extends BinarySemaphoreReleaseOptions {
+    (): void;
+}
+interface SemaphoreOptions extends BinarySemaphoreOptions {
+    maxConcurrency?: number;
+    isReadyFn?: SemaphoreIsReadyFuncType;
+}
+interface SemaphoreTaskItem extends BinarySemaphoreAcquireOptions {
+    resolve: (value: any) => void;
+    reject: (reason?: any) => void;
+    token?: any;
+}
+/**
+ * A binary semaphore implementation for managing concurrency in asynchronous operations.
+ * Unlike a general semaphore, a binary semaphore allows only one caller to acquire the semaphore at a time.
+ * It provides methods to acquire, release, and manage waiting tasks efficiently.
+ *
+ * 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 BinarySemaphore {
+    readonly waiting: Deque<SemaphoreTaskItem | undefined>;
+    protected free: any;
+    protected emitter: EventEmitter;
+    protected useDefaultTokens: boolean;
+    protected pauseFn?: () => void;
+    protected resumeFn?: () => void;
+    protected initTokenFn: (token?: any) => void;
+    protected paused: boolean;
+    protected _activeCount: number;
+    /**
+     * Creates a binary semaphore object for managing concurrency in asynchronous operations.
+     *
+     * @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 BinarySemaphore({ 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(options?: BinarySemaphoreOptions);
+    initFree(options?: BinarySemaphoreOptions): void;
+    onReleased(options?: BinarySemaphoreReleaseOptions): void;
+    init(options: BinarySemaphoreOptions): void;
+    _newReleaser(options?: BinarySemaphoreReleaseOptions): BinarySemaphoreReleaserFunc;
+    _dispatchTask(task: SemaphoreTaskItem, options?: BinarySemaphoreReleaseOptions): void;
+    lock(options?: BinarySemaphoreAcquireOptions): any;
+    unlock(token?: any): void;
+    /**
+     * Attempt to acquire a token from the semaphore, if one is available immediately. Otherwise, return undefined.
+     *
+     * @return Returns a token if the semaphore is not full; otherwise, returns `undefined`.
+     */
+    tryAcquire(options?: BinarySemaphoreAcquireOptions): 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.
+     * @param options.signal An optional AbortSignal to abort the acquisition process. If aborted, the promise will reject with an AbortError.
+     * @return A promise that resolves to a release function when a token is acquired. If the semaphore is full, the caller will be added to a waiting queue.
+     */
+    acquire(options?: BinarySemaphoreAcquireOptions): Promise<BinarySemaphoreReleaserFunc>;
+    /**
+     * Releases the semaphore, incrementing the number of free execution slots. If there are tasks in the waiting queue, the next task will be dispatched.
+     * @param options.token Optional token returned by `acquire()` when using a custom `initFn`. If provided, it will be used to unlock the semaphore.
+     */
+    release(options?: BinarySemaphoreReleaseOptions): 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[]>;
+    abort(reason?: any): void;
+    /**
+     * Get the total count of all active operations.
+     *
+     * This method returns the number of operations that are either:
+     * - Waiting in the queue to acquire the semaphore (`pendingCount`).
+     * - Already acquired the semaphore but have not yet released it.
+     *
+     * @returns {number} The total count of active operations, including both waiting and ongoing tasks.
+     */
+    get activeCount(): number;
+    /**
+     * Get the number of callers waiting on the semaphore, i.e. the number of pending promises.
+     *
+     * @returns The number of waiters in the waiting list.
+     */
+    get pendingCount(): number;
+}
+/**
+ * A Semaphore implementation for managing concurrency in asynchronous operations.
+ * Semaphores allow a fixed number of resources to be accessed concurrently.
+ * This class extends BinarySemaphore and adds support for a maximum concurrency limit and an optional readiness check.
+ *
+ * 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
+ *     isReadyFn: async () => {
+ *       // Check if the system is ready to handle more requests
+ *       return true;
+ *     },
+ *     pauseFn: () => {
+ *       console.log('Pausing the stream');
+ *     },
+ *     resumeFn: () => {
+ *       console.log('Resuming the stream');
+ *     }
+ *   }
+ * );
+ *
+ * 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 extends BinarySemaphore {
+    readonly maxConcurrency: number;
+    protected free: Deque<any>;
+    private isReady?;
+    /**
+     * 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 function that is called to opportunistically request pausing 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.
+     * @param options.isReadyFn An optional function that returns a boolean or a promise that resolves to a boolean indicating whether the semaphore is ready to accept new requests.
+     */
+    constructor(maxConcurrency: number | SemaphoreOptions, options?: SemaphoreOptions);
+    initFree(options: SemaphoreOptions): void;
+    tryAcquire(options?: BinarySemaphoreAcquireOptions): Promise<any | undefined> | any | undefined;
+    unlock(token?: any): void;
+    lock(options?: BinarySemaphoreAcquireOptions): any;
+    drain(): Promise<any[]>;
+}
+/**
+ * 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>;
+
+declare const ToolAsyncMultiTaskBit = 0;
+declare const ToolAsyncCancelableBit = 1;
+declare const ToolAsyncPriorityBit = 2;
+declare enum AsyncFeatureBits {
+    MultiTask = 0,
+    Cancelable = 1,
+    Priority = 2
+}
+declare enum AsyncFeatures {
+    MultiTask = 1,// B0001
+    Cancelable = 2,// B010
+    Priority = 4
+}
+type AsyncTaskId = string | number;
+interface CancelableAbilityOptions extends AbilityOptions {
+    asyncFeatures?: AsyncFeatures;
+    maxTaskConcurrency?: number;
+    isReadyFn?: SemaphoreIsReadyFuncType;
+}
+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;
+    _isReadyFn?: SemaphoreIsReadyFuncType;
+    [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;
+    getSemaphore(isReadyFn?: SemaphoreIsReadyFuncType | undefined): Semaphore | undefined;
+    static hasAsyncFeature(feature: AsyncFeatureBits): boolean;
+    hasAsyncFeature(feature: AsyncFeatureBits): boolean;
+    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;
+        isReadyFn?: SemaphoreIsReadyFuncType;
+    }): TaskPromise<Output>;
+    abort(reason?: string, data?: any): void;
+}
+declare const makeToolFuncCancelable: <T extends Function | (new (...args: any[]) => any)>(targetClass?: T | undefined, options?: AbilityOptions) => T & typeof CancelableAbility & (T extends new (...args: any[]) => any ? InstanceType<T> : T) & CancelableAbility;
+
+type Events = (string | RegExp)[];
+type Client = {
+    req: IncomingMessage;
+    res: ServerResponse;
+    events?: Events;
+};
+declare const SSEChannelAlreadyClosedErrCode = 498;
+/**
+ * A class for creating Server-Sent Events (SSE) channels.
+ * @example
+ * const sseChannel = new SSEChannel({ pingInterval: 5000 })
+ * sseChannel.publish('Hello, world!', 'greeting')
+ */
+declare class SSEChannel {
+    _active: boolean;
+    clients: Set<Client>;
+    messages: Record<string, any>[];
+    nextID: number;
+    options: Record<string, any>;
+    pingTimer?: NodeJS.Timeout;
+    get active(): boolean;
+    set active(v: boolean);
+    /**
+     * Creates a new SSE channel.
+     * @param options - The options for the SSE channel.
+     */
+    constructor(options?: Record<string, any>);
+    /**
+     * Publishes a message to the SSE channel.
+     * @param {string | Record<string, any>} data - The data to send. It can be a string or an object.
+     * @param {string} eventName - The name of the event.
+     * @returns {number | undefined} - Returns the ID of the message.
+     * @throws Will throw an error if the channel is closed.
+     */
+    publish(data?: string | Record<string, any>, eventName?: string): number | undefined;
+    /**
+     * Subscribes a client to the SSE channel.
+     * @param {IncomingMessage} req - The request object.
+     * @param {ServerResponse} res - The response object.
+     * @param {Events} events - The events to subscribe to.
+     * @returns {Client} - Returns the client object.
+     * @throws Will throw an error if the channel is closed.
+     */
+    subscribe(req: IncomingMessage, res: ServerResponse, events?: Events): {
+        req: IncomingMessage;
+        res: ServerResponse<IncomingMessage>;
+        events: Events | undefined;
+    };
+    /**
+     * Unsubscribes a client from the SSE channel.
+     * @param {Client} c - The client to unsubscribe.
+     */
+    unsubscribe(c: Client): void;
+    clearClients(): void;
+    /**
+     * Lists the clients connected to the SSE channel grouped by IP address.
+     * @returns - Returns an object where the keys are the IP addresses and the values are the number of clients connected from each IP.
+     */
+    listClients(): Record<string, number>;
+    /**
+     * Gets the number of clients subscribed to the SSE channel.
+     * @returns - Returns the number of clients.
+     */
+    getSubscriberCount(): number;
+}
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+interface ClientFuncItem extends RemoteFuncItem {
+}
+declare interface ClientTools extends ClientFuncItem {
+    [name: string]: any;
+}
+declare class ClientTools extends ToolFunc {
+    apiRoot: string | undefined;
+    private static _apiRoot?;
+    static get apiRoot(): string | undefined;
+    static setApiRoot(v: string): void;
+    static loadFrom(): Promise<void>;
+    static loadFromSync(items: Funcs): void;
+    static fetch(name: string, objParam?: any): Promise<any>;
+    getUrlParams(objParam: any): string;
+    fetch(objParam?: any, act?: ActionName, subName?: any): Promise<Response>;
+    errorFrom(res: Response): Promise<_isdk_common_error.CommonError>;
+    func(objParam: any): Promise<any>;
+}
+declare const ClientToolFuncSchema: {
+    apiRoot: {
+        type: string;
+        get(this: any): any;
+        set(this: any, value: string): void;
+    };
+    action: {
+        type: string;
+        assign(value: ActionName, dest: any, src?: any, name?: string, options?: any): "get" | "post" | "put" | "delete" | "patch" | "list" | "res";
+    };
+    fetchOptions: {
+        type: string;
+    };
+    allowExportFunc: {
+        type: string;
+    };
+};
+
+/**
+ * Convention: Always pass _req, _res
+ */
+interface ServerFuncParams {
+    _req?: IncomingMessage;
+    _res?: ServerResponse;
+    [name: string]: any;
+}
+interface ServerFuncItem extends RemoteFuncItem {
+    allowExportFunc?: boolean;
+}
+declare interface ServerTools extends ServerFuncItem {
+    [name: string]: any;
+}
+declare class ServerTools extends ToolFunc {
+    private static _apiRoot?;
+    static get apiRoot(): string | undefined;
+    static setApiRoot(v: string): void;
+    static toJSON(): {
+        [name: string]: ServerTools;
+    };
+    func({}: {}): Promise<any> | any;
+}
+declare const ServerToolFuncSchema: {
+    apiRoot: {
+        type: string;
+        get(this: any): any;
+        set(this: any, value: string): void;
+    };
+    action: {
+        type: string;
+        assign(value: ActionName, dest: any, src?: any, name?: string, options?: any): "get" | "post" | "put" | "delete" | "patch" | "list" | "res";
+    };
+    fetchOptions: {
+        type: string;
+    };
+    allowExportFunc: {
+        type: string;
+    };
+};
+
+declare class EventToolFunc extends ToolFunc {
+    _emitter: EventEmitter;
+    description: string;
+    result: string;
+    get emitter(): EventEmitter;
+    func(): EventEmitter;
+}
+declare const event: EventToolFunc;
+
+declare const SecondaryCache: typeof Cache;
+declare function _lrucache(this: ToolFunc, { key, value, options }?: {
+    key?: string;
+    value?: any;
+    options?: ICacheOptions | number;
+}): Cache;
+declare function createLRUCache(name: string, options?: ICacheOptions | number): ToolFunc;
+declare const lrucache: ToolFunc;
+
+interface RpcMethodsClientFuncParams {
+    act?: string;
+    [name: string]: any;
+}
+declare class RpcMethodsClientTool extends ClientTools {
+    _func(action: ActionName, options: RpcMethodsClientFuncParams): Promise<any>;
+    func(options: RpcMethodsClientFuncParams): Promise<any>;
+    assignMethods(methods: string[]): void;
+}
+
+interface ResClientFuncParams extends RpcMethodsClientFuncParams {
+    id?: string | number;
+}
+interface ResClientTools {
+    get?({ id }: ResClientFuncParams): any;
+    post?(options: ResClientFuncParams): any;
+    put?({ id }: ResClientFuncParams): any;
+    delete?({ id }: ResClientFuncParams): any;
+    list?(options: ResClientFuncParams): any;
+}
+declare class ResClientTools extends RpcMethodsClientTool {
+    fetch(options: ResClientFuncParams, action: ActionName): Promise<Response>;
+}
+
+interface EventClientFuncParams {
+    event?: string | string[];
+    data?: any;
+    act?: 'sub' | 'pub' | 'unsub' | 'init';
+    listener?: (...args: any[]) => void;
+}
+declare class EventClient extends ResClientTools {
+    _es: EventSource | undefined;
+    _esEvents: string[] | undefined;
+    _sseEvents: Record<string, (e: MessageEvent) => void>;
+    _forwardEvents: Set<string>;
+    get evtSource(): EventSource;
+    get active(): boolean;
+    set active(v: boolean);
+    name: string;
+    description: string;
+    initEventSource(events?: string | string[]): EventSource;
+    esListener(event: MessageEvent): void;
+    ebListener: (this: Event, ...data: any[]) => Promise<void>;
+    /**
+     * subscribe server sent event(SSE)
+     * @param events
+     */
+    subscribe(events: string | string[]): Promise<any>;
+    /**
+     * unsubscribe server sent event(SSE)
+     * @param events
+     */
+    unsubscribe(events: string | string[]): Promise<any>;
+    /**
+     * forward local event(s) to server
+     *
+     * subscribe these local events to forward/publish to server
+     *
+     * Note: pls backendEventable(ClientTools or EventClient) first
+     * @param events
+     */
+    forwardEvent(events: string | string[]): void;
+    /**
+     * unforward local event(s) to server
+     *
+     * unsubscribe these local events not to forward/publish to server
+     *
+     * Note: pls backendEventable(ClientTools or EventClient) first
+     * @param events
+     */
+    unforwardEvent(events: string | string[]): void;
+    init(events: string | string[]): Promise<any>;
+}
+declare const eventClient: EventClient;
+
+interface RpcMethodsServerFuncParams extends ServerFuncParams {
+    act?: string;
+}
+interface RpcMethodsServerTool {
+    methods: string[];
+}
+declare class RpcMethodsServerTool extends ServerTools {
+    static SpecialRpcMethodNames?: string[];
+    params: FuncParams;
+    get SpecialRpcMethodNames(): any;
+    initRpcMethods(methods?: string[]): void;
+    constructor(name: string | Function | FuncItem, options?: FuncItem | any);
+    cast(key: string, value: any): any;
+    getMethodFromParams(params: RpcMethodsServerFuncParams): string | undefined;
+    castParams(params: RpcMethodsServerFuncParams): RpcMethodsServerFuncParams;
+    func(params: RpcMethodsServerFuncParams): any;
+}
+
+interface ResServerFuncParams extends RpcMethodsServerFuncParams {
+    id?: string | number;
+    val?: any;
+}
+interface ResServerTools {
+    get?({ id }: ResServerFuncParams): any;
+    post?(options: ResServerFuncParams): any;
+    put?({ id }: ResServerFuncParams): any;
+    delete?({ id }: ResServerFuncParams): any;
+    list?(options?: ResServerFuncParams): any;
+}
+declare class ResServerTools extends RpcMethodsServerTool {
+    static SpecialRpcMethodNames: any;
+    action: ActionName;
+    params: FuncParams;
+    constructor(name: string | Function | FuncItem, options?: FuncItem | any);
+    getMethodFromParams(params: ResServerFuncParams): string | undefined;
+    castParams(params: RpcMethodsServerFuncParams): RpcMethodsServerFuncParams;
+}
+
+interface EventServerFuncParams extends ServerFuncParams {
+    event?: string | string[];
+    data?: any;
+    act?: 'sub' | 'pub' | 'unsub';
+}
+declare class EventServer extends ResServerTools {
+    static _sse: SSEChannel | undefined;
+    static get sse(): SSEChannel;
+    name: string;
+    description: string;
+    result: string;
+    depends: {
+        "event-bus": EventToolFunc;
+    };
+    get sse(): any;
+    static publish(data: any, event: string): number | undefined;
+    static ebListener: (this: Event, ...data: any[]) => void;
+    static subscribe(req: IncomingMessage, res: ServerResponse, events?: string[]): {
+        req: IncomingMessage;
+        res: ServerResponse<IncomingMessage>;
+        events: (string | RegExp)[] | undefined;
+    };
+    static alreadyForward(event: string): true | undefined;
+    publishSSE(data: any, event: string): any;
+    subscribeSSE(req: IncomingMessage, res: ServerResponse, events?: string | string[]): any;
+    forward(events: string | string[]): void;
+    unforward(events: string | string[]): void;
+    list({ _req, _res, event }: EventServerFuncParams): void;
+    $sub({ event }: EventServerFuncParams): {
+        event: string | string[];
+    } | undefined;
+    $unsub({ event }: EventServerFuncParams): {
+        event: string | string[];
+    } | undefined;
+    $publish({ event: events, data }: EventServerFuncParams): {
+        event: string[];
+    } | undefined;
+    isStream(params: ServerFuncParams): boolean;
+}
+declare const eventServer: EventServer;
+
+declare function registerCoreTools(): void;
+
+export { event as $, type AsyncTaskId as A, type BinarySemaphoreOptions as B, type CancelableAbilityOptions as C, DefaultAsyncSemaphoreCapacity as D, type FuncParams as E, type FuncParamType as F, type TFunc as G, type BaseFuncItem as H, type FuncItem as I, type BaseFunc as J, type Funcs as K, type ToolFuncPackage as L, ToolFunc as M, ToolFuncSchema as N, type ClientFuncItem as O, PASSING_SCORE as P, ClientTools as Q, RemoteToolFuncSchema as R, SSEChannelAlreadyClosedErrCode as S, ToolAsyncMultiTaskBit as T, ClientToolFuncSchema as U, type ServerFuncParams as V, type ServerFuncItem as W, ServerTools as X, ServerToolFuncSchema as Y, registerCoreTools as Z, EventToolFunc as _, type AIModelNameRules as a, SecondaryCache as a0, _lrucache as a1, createLRUCache as a2, lrucache as a3, type EventClientFuncParams as a4, EventClient as a5, eventClient as a6, type EventServerFuncParams as a7, EventServer as a8, eventServer as a9, type ResClientFuncParams as aa, ResClientTools as ab, type ResServerFuncParams as ac, ResServerTools as ad, ActionNames as b, type ActionName as c, type AIModelNameRuleFn as d, type AIModelNameRule as e, type RemoteFuncItem as f, SSEChannel as g, type SemaphoreIsReadyFuncType as h, type BinarySemaphoreAcquireOptions as i, type BinarySemaphoreReleaseOptions as j, type BinarySemaphoreReleaserFunc as k, type SemaphoreOptions as l, type SemaphoreTaskItem as m, BinarySemaphore as n, Semaphore as o, RateLimit as p, ToolAsyncCancelableBit as q, ToolAsyncPriorityBit as r, AsyncFeatureBits as s, AsyncFeatures as t, TaskAbortController as u, type TaskAbortControllers as v, type TaskPromise as w, CancelableAbility as x, makeToolFuncCancelable as y, type FuncParam as z };