@isdk/ai-tool 0.0.2

package/dist/funcs.mjs

@@ -0,0 +1,37 @@
+import {
+  EventClient,
+  EventServer,
+  EventToolFunc,
+  _lrucache,
+  createLRUCache,
+  event,
+  eventClient,
+  eventServer,
+  getDefaultSimilarPassingScore,
+  isSimilar,
+  lrucache,
+  mergeSegments,
+  registerCoreTools,
+  segments,
+  similarity,
+  splitSegments
+} from "./chunk-PKECBABP.mjs";
+import "./chunk-EZFPVSGF.mjs";
+export {
+  EventClient,
+  EventServer,
+  EventToolFunc,
+  _lrucache,
+  createLRUCache,
+  event,
+  eventClient,
+  eventServer,
+  getDefaultSimilarPassingScore,
+  isSimilar,
+  lrucache,
+  mergeSegments,
+  registerCoreTools,
+  segments,
+  similarity,
+  splitSegments
+};

package/dist/index-D4KjfAKl.d.mts

@@ -0,0 +1,606 @@
+import { EventEmitter, Event } from 'events-ex';
+import { AdvancePropertyManager } from 'property-manager';
+import { ICacheOptions, Cache } from 'secondary-cache';
+import { IncomingMessage, ServerResponse } from 'http';
+import { AbstractError } from 'abstract-error';
+
+type FuncParamType = string;
+interface FuncParam {
+    name?: string;
+    type?: FuncParamType;
+    required?: boolean;
+    description?: string;
+    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;
+}
+interface FuncItem extends BaseFuncItem {
+    func?: TFunc;
+}
+interface BaseFunc extends BaseFuncItem {
+    func(...params: any): any;
+}
+interface Funcs {
+    [name: string]: ToolFunc;
+}
+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 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;
+}
+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[];
+    };
+};
+
+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;
+    };
+    stream: {
+        type: string;
+    };
+};
+interface RemoteFuncItem extends BaseFuncItem {
+    apiRoot?: string;
+    action?: ActionName;
+    fetchOptions?: any;
+    stream?: boolean;
+}
+
+type ErrorCodeType = number | string;
+declare enum ErrorCode {
+    OK = 200,
+    BadRequest = 400,
+    InvalidArgument = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Corruption = 409,
+    Aborted = 499,
+    InternalError = 500,
+    NotImplemented = 501,
+    NotSupported = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504
+}
+declare const InternalErrorCode = ErrorCode.InternalError;
+declare const NotImplementedErrorCode = ErrorCode.NotImplemented;
+declare const NotFoundErrorCode = ErrorCode.NotFound;
+declare const AlreadyExistsErrorCode = ErrorCode.Conflict;
+declare const AbortErrorCode = ErrorCode.Aborted;
+/**
+ * BaseError class that extends the Error class.
+ *
+ * @example
+ * // Create a custom error
+ * class CustomError extends BaseError {
+ *   static code = 'customError';
+ *   constructor(message: string) {
+ *     super(message);
+ *   }
+ * }
+ *
+ * // Throw the custom error
+ * throw new CustomError('This is a custom error');
+ *
+ * @description
+ * This class is used to create custom errors that extend the built-in Error class. It provides a way to define custom error codes and additional data associated with the error.
+ *
+ * @property {ErrorCodeType} code - The error code associated with the error.
+ * @property {string} caller - The name of the function that threw the error.
+ * @property {ErrorCodeType} code - The error code associated with the error.
+ * @property {any} data - Additional data associated with the error.
+ *
+ * @method toJSON - Returns a JSON representation of the error.
+ * @method fromJSON - Creates a new BaseError instance from a JSON representation.
+ */
+declare class BaseError extends AbstractError {
+    /**
+     * The error code associated with the error.
+     */
+    static code: ErrorCodeType;
+    caller: string;
+    code: ErrorCodeType;
+    data?: any;
+    static createErrorClass(aType: string, aErrorCode?: number | string | typeof AbstractError, ParentErrorClass?: typeof BaseError): typeof BaseError;
+    /**
+     * Constructs a new BaseError instance.
+     *
+     * @param {string} message - The error message.
+     * @param {ErrorCodeType} [code] - The error code.
+     * @param {string|object} [name] - The error name or additional properties.
+     */
+    constructor(message: string, code?: ErrorCodeType, name?: string | object);
+    /**
+     * Returns a JSON representation of the error.
+     *
+     * @returns {object} A JSON representation of the error.
+     */
+    toJSON(): any;
+    /**
+     * Creates a new BaseError instance from a JSON representation.
+     *
+     * @param {object} json - A JSON representation of the error.
+     * @returns {BaseError} A new BaseError instance.
+     */
+    fromJSON(json: any): BaseError;
+}
+declare class CommonError extends BaseError {
+    constructor(message: string, name?: string | Record<string, any>, status?: ErrorCodeType);
+}
+/**
+ * Represents an error when a function or method is not implemented.
+ * Inherits from BaseError.
+ *
+ * @example
+ * throw new NotImplementationError()
+ *
+ * @extends CommonError
+ */
+declare class NotImplementationError extends CommonError {
+    constructor(msg?: string, name?: string | Record<string, any>);
+}
+/**
+ * Represents an error when a requested resource is not found.
+ * Inherits from BaseError.
+ *
+ * @example
+* throw new NotFoundError('user', { id: 123 })
+*
+* @extends CommonError
+*/
+declare class NotFoundError extends CommonError {
+    static code: ErrorCode;
+    constructor(what: string | number, name?: string | Record<string, any>);
+}
+/**
+ * Represents an error when a requested resource already exists.
+ * Inherits from BaseError.
+ *
+ * @example
+* throw new AlreadyExistsError('user', { id: 123 })
+*
+* @extends CommonError
+*/
+declare class AlreadyExistsError extends CommonError {
+    static code: ErrorCode;
+    constructor(what: string | number, name?: string | Record<string, any>);
+}
+declare class AbortError extends CommonError {
+    static code: ErrorCode;
+    constructor(what?: string, name?: string | Record<string, any>);
+}
+/**
+ * Create an error object
+ * @param message - Error message
+ * @param name - Error name, optional
+ * @param status - Error status code, default to 500
+ * @returns Error object
+ */
+declare function createError(message: string, name?: string | Record<string, any>, status?: ErrorCode | ErrorCodeType): CommonError;
+/**
+ * Throw an error
+ * @param message - Error message
+ * @param name - Error name, optional
+ * @param status - Error status code, default to 500
+ * @throws {BaseError} Throws a BaseError object
+ */
+declare function throwError(message: string, name?: string | Record<string, any>, status?: ErrorCode | ErrorCodeType): void;
+
+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;
+}
+
+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<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: "get" | "post" | "put" | "delete" | "patch" | "list" | "res", dest: any, src?: any, name?: string | undefined, options?: any): "get" | "post" | "put" | "delete" | "patch" | "list" | "res";
+    };
+    fetchOptions: {
+        type: string;
+    };
+    allowExportFunc: {
+        type: string;
+    };
+    stream: {
+        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;
+    };
+    isStream(params: ServerFuncParams): boolean | undefined;
+    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: "get" | "post" | "put" | "delete" | "patch" | "list" | "res", dest: any, src?: any, name?: string | undefined, options?: any): "get" | "post" | "put" | "delete" | "patch" | "list" | "res";
+    };
+    fetchOptions: {
+        type: string;
+    };
+    allowExportFunc: {
+        type: string;
+    };
+    stream: {
+        type: string;
+    };
+};
+
+declare class EventToolFunc extends ToolFunc {
+    _emitter: EventEmitter;
+    description: string;
+    result: string;
+    get emitter(): EventEmitter;
+    func(): EventEmitter;
+}
+declare const event: EventToolFunc;
+
+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;
+
+declare const similarity: ServerTools;
+
+declare function getDefaultSimilarPassingScore(modelId: string): number;
+declare const isSimilar: ServerTools;
+
+declare const splitSegments: ServerTools;
+
+declare const mergeSegments: ServerTools;
+
+declare const segments: ServerTools;
+
+interface ResClientFuncParams {
+    id?: string | number;
+    act?: string;
+    [name: string]: any;
+}
+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 ClientTools {
+    fetch(options: ResClientFuncParams, action: ActionName): Promise<Response>;
+    _func(action: ActionName, options: ResClientFuncParams): Promise<any>;
+    func(options: ResClientFuncParams): Promise<any>;
+    assignMethods(methods: string[]): void;
+}
+declare const ResClientToolsSchema: {
+    methods: {
+        type: string;
+        assign(value: string[], dest: any, src?: any, name?: string, options?: any): void;
+    };
+};
+
+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 ResServerFuncParams extends ServerFuncParams {
+    id?: string | number;
+    val?: any;
+    act?: string;
+}
+interface ResServerTools {
+    methods: string[];
+    get?({ id }: ResServerFuncParams): any;
+    post?(options: ResServerFuncParams): any;
+    put?({ id }: ResServerFuncParams): any;
+    delete?({ id }: ResServerFuncParams): any;
+    list?(options?: ResServerFuncParams): any;
+}
+declare class ResServerTools extends ServerTools {
+    action: ActionName;
+    params: FuncParams;
+    constructor(name: string | Function | FuncItem, options?: FuncItem | any);
+    cast(key: string, value: any): any;
+    getMethodFromParams(params: ResServerFuncParams): string | undefined;
+    func(params: ResServerFuncParams): any;
+}
+declare const ResServerToolsSchema: {
+    methods: {
+        type: string;
+    };
+};
+
+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 { segments as $, type AIModelNameRules as A, BaseError as B, CommonError as C, ClientToolFuncSchema as D, type ErrorCodeType as E, type FuncParamType as F, type ServerFuncParams as G, type ServerFuncItem as H, InternalErrorCode as I, ServerTools as J, ServerToolFuncSchema as K, registerCoreTools as L, EventToolFunc as M, NotImplementedErrorCode as N, event as O, PASSING_SCORE as P, createLRUCache as Q, RemoteToolFuncSchema as R, SSEChannelAlreadyClosedErrCode as S, type TFunc as T, lrucache as U, similarity as V, getDefaultSimilarPassingScore as W, isSimilar as X, splitSegments as Y, mergeSegments as Z, _lrucache as _, ActionNames as a, type EventClientFuncParams as a0, EventClient as a1, eventClient as a2, type EventServerFuncParams as a3, EventServer as a4, eventServer as a5, type ResClientFuncParams as a6, ResClientTools as a7, ResClientToolsSchema as a8, type ResServerFuncParams as a9, ResServerTools as aa, ResServerToolsSchema as ab, type ActionName as b, type AIModelNameRuleFn as c, type AIModelNameRule as d, type RemoteFuncItem as e, ErrorCode as f, NotFoundErrorCode as g, AlreadyExistsErrorCode as h, AbortErrorCode as i, NotImplementationError as j, NotFoundError as k, AlreadyExistsError as l, AbortError as m, createError as n, SSEChannel as o, type FuncParam as p, type FuncParams as q, type BaseFuncItem as r, type FuncItem as s, throwError as t, type BaseFunc as u, type Funcs as v, ToolFunc as w, ToolFuncSchema as x, type ClientFuncItem as y, ClientTools as z };