@isdk/ai-tool 0.5.8 → 0.7.0

package/dist/index.d.ts

@@ -1,28 +1,29 @@
 import * as custom_ability from 'custom-ability';
 export { createAbilityInjector } from 'custom-ability';
 export { toRegExp } from 'util-ex';
-import { A as AsyncTaskId, a as AIModelNameRules } from './index-BkwhCK1q.js';
-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-BkwhCK1q.js';
+import { A as AsyncTaskId, a as AIModelNameRules, I as IPubSubServerTransport, P as PubSubClientId, b as PubSubServerSession, c as IPubSubClientTransport, d as PubSubClientStream, e as IToolTransport, S as ServerTools, T as ToolTransport, C as ClientToolTransport, F as Funcs, f as ActionName } from './index-BCco-g_I.js';
+export { j as AIModelNameRule, i as AIModelNameRuleFn, h as ActionNames, x as AsyncFeatureBits, y as AsyncFeatures, V as BaseFunc, Q as BaseFuncItem, r as BinarySemaphore, m as BinarySemaphoreAcquireOptions, B as BinarySemaphoreOptions, n as BinarySemaphoreReleaseOptions, o as BinarySemaphoreReleaserFunc, J as CancelableAbility, z as CancelableAbilityOptions, a1 as ClientFuncItem, a2 as ClientToolFuncSchema, a0 as ClientTools, D as DefaultAsyncSemaphoreCapacity, ae as EventClient, ad as EventClientFuncParams, ah as EventServer, ag as EventServerFuncParams, a7 as EventToolFunc, U as FuncItem, Z as FuncMetaSymbol, M as FuncParam, L as FuncParamType, N as FuncParams, ao as IClientToolTransport, g as PASSING_SCORE, aq as PubSubClient, ap as PubSubCtx, t as RateLimit, k as RemoteFuncItem, R as RemoteToolFuncSchema, aj as ResClientFuncParams, ak as ResClientTools, al as ResServerFuncParams, am as ResServerTools, an as RpcMethodHandler, a9 as SecondaryCache, s as Semaphore, l as SemaphoreIsReadyFuncType, p as SemaphoreOptions, q as SemaphoreTaskItem, a4 as ServerFuncItem, a3 as ServerFuncParams, a5 as ServerToolFuncSchema, O as TFunc, E as TaskAbortController, G as TaskAbortControllers, H as TaskPromise, v as ToolAsyncCancelableBit, u as ToolAsyncMultiTaskBit, w as ToolAsyncPriorityBit, X as ToolFunc, W as ToolFuncPackage, Y as ToolFuncSchema, aa as _lrucache, ab as createLRUCache, a8 as event, af as eventClient, ai as eventServer, $ as funcGetMeta, _ as funcWithMeta, ac as lrucache, K as makeToolFuncCancelable, a6 as registerCoreTools } from './index-BCco-g_I.js';
+import * as _isdk_common_error from '@isdk/common-error';
 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 { StringTemplateOptions, StringTemplate } from '@isdk/template-engines';
+export { EnvStringTemplate as EnvPromptTemplate, FStringTemplate as FStringPromptTemplate, GolangStringTemplate as GolangPromptTemplate, StringTemplate as PromptTemplate, StringTemplateOptions as PromptTemplateOptions, createHfValueFunc, defaultTemplateFormat, expandEnv, expandObjEnv, getEnvVairables } from '@isdk/template-engines';
 import { Event, EventEmitter } from 'events-ex';
 export { EventEmitter, states as EventStates, eventable, wrapEventEmitter } from 'events-ex';
+import http, { IncomingMessage, ServerResponse } from 'http';
 import * as _base32768 from 'base32768';
 import { IDataType } from 'hash-wasm';
+export { ConfigFile, FilenameReservedRegex, SanitizeFilenameOptions, WindowsReservedNameRegex, extNameLevel, getMultiLevelExtname, isValidFilename, isValidFilepath, parseYaml, registerYamlTag, sanitizeFilename, sanitizeFilepath, stringifyYaml } from '@isdk/util';
 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-.js';
-import { PreTrainedTokenizer } from '@xenova/transformers';
+import { PreTrainedTokenizer } from '@huggingface/transformers';
 export { NIL as uuidNIL, parse as uuidParse, stringify as uuidStringify, validate as uuidValidate, version as uuidVersion, v1 as uuidv1, v4 as uuidv4, v5 as uuidv5 } from 'uuid';
 export { 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 { add as addDate, formatISO, parse as parseDateFormat, parseISO, toDate } from 'date-fns';
 export { LRUCache } from 'secondary-cache';
 import 'property-manager';
-import 'http';
 
 declare const AITextGenerationFinishReasons: readonly ["stop", "length", "content_filter", "tool_calls", "function_call", "abort", "error", "other", null];
 type AITextGenerationFinishReason = typeof AITextGenerationFinishReasons[number];
@@ -46,6 +47,7 @@ interface AIResult<TValue = any, TOptions = any> {
 declare const AIMessageTypes: readonly ["human", "ai", "generic", "system", "tool"];
 type AIMessageType = typeof AIMessageTypes[number];
 declare const AIChatRoles: readonly ["user", "assistant", "system", "tool", "tool_calls"];
+declare const StrangeHumanName = "\u964C\u751F\u4EBA";
 type AIChatRole = (typeof AIChatRoles[number]) & string;
 type AIChatMessageParam = AIChatMessageParamBase | AIChatSystemMessageParam | AIChatUserMessageParam | AIChatAssistantMessageParam | AIChatToolMessageParam;
 interface AIChatMessageParamBase {
@@ -132,60 +134,6 @@ interface AIChatToolTypeObject {
 }
 declare function messagesToText(messages: AIChatMessageParamBase[]): string;
 
-/**
- * Prompt Type
- * defaults to `chat`
- */
-declare const PromptTypes: readonly ["chat", "char", "plan"];
-type PromptType = typeof PromptTypes[number];
-declare const PromptTemplateTypes: readonly ["internal", "hf", "fill"];
-type PromptTemplateType = typeof PromptTemplateTypes[number];
-
-declare const defaultTemplateFormat = "default";
-interface PromptTemplateOptions {
-    template?: string;
-    data?: Record<string, any>;
-    templateFormat?: string;
-    inputVariables?: string[];
-    compiledTemplate?: any;
-    ignoreInitialize?: boolean;
-    [name: string]: any;
-}
-declare class PromptTemplate extends BaseFactory {
-    compiledTemplate: any;
-    template: string;
-    templateFormat: string | undefined;
-    data: Record<string, any> | undefined;
-    inputVariables: string[] | undefined;
-    static from(template?: string | PromptTemplateOptions, options?: PromptTemplateOptions): PromptTemplate;
-    static format(options: PromptTemplateOptions): Promise<string>;
-    /**
-     * If the given options.template is the template, perform formatting using that template.
-     * @param options - The options object to check for being a template and to format.
-     * @returns A Promise that resolves to the formatted result if options is a template; otherwise, no value is returned.
-     */
-    static formatIf(options: PromptTemplateOptions): Promise<string | undefined>;
-    static isTemplate(templateOpt: PromptTemplateOptions): any;
-    /**
-     * Validate/filter the data in inputVariables
-     * @param data
-     * @returns
-     */
-    filterData(data: Record<string, any>): Record<string, any>;
-    constructor(template?: string | PromptTemplateOptions, options?: PromptTemplateOptions);
-    _initialize(options?: PromptTemplateOptions): void;
-    initialize(options?: PromptTemplateOptions): void;
-    _format(data: Record<string, any>): string | Promise<string>;
-    format(data?: Record<string, any>): Promise<string>;
-    /**
-     * it can make sense to "partial" a prompt template - eg pass in a subset of the required values, as to create a new prompt template which expects only the remaining subset of values.
-     * @param data the partial data
-     * @returns the new partial PromptTemplate instance
-     */
-    partial(data: Record<string, any>): PromptTemplate;
-    toJSON(options?: PromptTemplateOptions): PromptTemplateOptions;
-}
-
 type PromptExamples<T = any> = Iterable<PromiseLike<T> | T> | AsyncIterable<T>;
 interface PromptExampleSelectorOptions {
     /**
@@ -269,394 +217,8 @@ declare class PromptExampleSelector<T = any> {
     [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
 }
 
-/**
- * Represents tokens that our language understands in parsing.
- */
-declare const TOKEN_TYPES: Readonly<{
-    Text: "Text";
-    NumericLiteral: "NumericLiteral";
-    BooleanLiteral: "BooleanLiteral";
-    NullLiteral: "NullLiteral";
-    StringLiteral: "StringLiteral";
-    Identifier: "Identifier";
-    Equals: "Equals";
-    OpenParen: "OpenParen";
-    CloseParen: "CloseParen";
-    OpenStatement: "OpenStatement";
-    CloseStatement: "CloseStatement";
-    OpenExpression: "OpenExpression";
-    CloseExpression: "CloseExpression";
-    OpenSquareBracket: "OpenSquareBracket";
-    CloseSquareBracket: "CloseSquareBracket";
-    OpenCurlyBracket: "OpenCurlyBracket";
-    CloseCurlyBracket: "CloseCurlyBracket";
-    Comma: "Comma";
-    Dot: "Dot";
-    Colon: "Colon";
-    Pipe: "Pipe";
-    CallOperator: "CallOperator";
-    AdditiveBinaryOperator: "AdditiveBinaryOperator";
-    MultiplicativeBinaryOperator: "MultiplicativeBinaryOperator";
-    ComparisonBinaryOperator: "ComparisonBinaryOperator";
-    UnaryOperator: "UnaryOperator";
-    Set: "Set";
-    If: "If";
-    For: "For";
-    In: "In";
-    Is: "Is";
-    NotIn: "NotIn";
-    Else: "Else";
-    EndIf: "EndIf";
-    ElseIf: "ElseIf";
-    EndFor: "EndFor";
-    And: "And";
-    Or: "Or";
-    Not: "UnaryOperator";
-    Macro: "Macro";
-    EndMacro: "EndMacro";
-}>;
-type TokenType = keyof typeof TOKEN_TYPES;
-/**
- * Represents a single token in the template.
- */
-declare class Token {
-    value: string;
-    type: TokenType;
-    /**
-     * Constructs a new Token.
-     * @param {string} value The raw value as seen inside the source code.
-     * @param {TokenType} type The type of token.
-     */
-    constructor(value: string, type: TokenType);
-}
-interface PreprocessOptions {
-    trim_blocks?: boolean;
-    lstrip_blocks?: boolean;
-}
-/**
- * Generate a list of tokens from a source string.
- */
-declare function tokenize(source: string, options?: PreprocessOptions): Token[];
-
-/**
- * Statements do not result in a value at runtime. They contain one or more expressions internally.
- */
-declare class Statement {
-    isStatement?: boolean;
-    type: string;
-}
-/**
- * Defines a block which contains many statements. Each chat template corresponds to one Program.
- */
-declare class Program extends Statement {
-    body: Statement[];
-    type: string;
-    constructor(body: Statement[]);
-}
-
-/**
- * Generate the Abstract Syntax Tree (AST) from a list of tokens.
- * Operator precedence can be found here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table
- */
-declare function parse(tokens: Token[]): Program;
-
-type AnyRuntimeValue = NumericValue | StringValue | BooleanValue | ObjectValue | ArrayValue | FunctionValue | NullValue | UndefinedValue;
-/**
- * Abstract base class for all Runtime values.
- * Should not be instantiated directly.
- */
-declare abstract class RuntimeValue<T> {
-    type: string;
-    value: T;
-    /**
-     * A collection of built-in functions for this type.
-     */
-    builtins: Map<string, AnyRuntimeValue>;
-    /**
-     * Creates a new RuntimeValue.
-     */
-    constructor(value?: T);
-    /**
-     * Determines truthiness or falsiness of the runtime value.
-     * This function should be overridden by subclasses if it has custom truthiness criteria.
-     * @returns {BooleanValue} BooleanValue(true) if the value is truthy, BooleanValue(false) otherwise.
-     */
-    __bool__(): BooleanValue;
-    toString(): string;
-    toJSON(): any;
-}
-/**
- * Represents a numeric value at runtime.
- */
-declare class NumericValue extends RuntimeValue<number> {
-    type: string;
-}
-/**
- * Represents a string value at runtime.
- */
-declare class StringValue extends RuntimeValue<string> {
-    type: string;
-    builtins: Map<string, AnyRuntimeValue>;
-}
-/**
- * Represents a boolean value at runtime.
- */
-declare class BooleanValue extends RuntimeValue<boolean> {
-    type: string;
-}
-/**
- * Represents an Object value at runtime.
- */
-declare class ObjectValue extends RuntimeValue<Map<string, AnyRuntimeValue>> {
-    orgValue?: Record<string, any> | undefined;
-    type: string;
-    constructor(value: Map<string, AnyRuntimeValue>, orgValue?: Record<string, any> | undefined);
-    toString(): string;
-    toJSON(): Record<string, any>;
-    /**
-     * NOTE: necessary to override since all JavaScript arrays are considered truthy,
-     * while only non-empty Python arrays are consider truthy.
-     *
-     * e.g.,
-     *  - JavaScript:  {} && 5 -> 5
-     *  - Python:      {} and 5 -> {}
-     */
-    __bool__(): BooleanValue;
-    builtins: Map<string, AnyRuntimeValue>;
-}
-/**
- * Represents an Array value at runtime.
- */
-declare class ArrayValue extends RuntimeValue<AnyRuntimeValue[]> {
-    type: string;
-    builtins: Map<string, AnyRuntimeValue>;
-    /**
-     * NOTE: necessary to override since all JavaScript arrays are considered truthy,
-     * while only non-empty Python arrays are consider truthy.
-     *
-     * e.g.,
-     *  - JavaScript:  [] && 5 -> 5
-     *  - Python:      [] and 5 -> []
-     */
-    __bool__(): BooleanValue;
-}
-/**
- * Represents a Function value at runtime.
- */
-declare class FunctionValue extends RuntimeValue<(args: AnyRuntimeValue[], scope: Environment) => AnyRuntimeValue> {
-    type: string;
-}
-/**
- * Represents a Null value at runtime.
- */
-declare class NullValue extends RuntimeValue<null> {
-    type: string;
-}
-/**
- * Represents an Undefined value at runtime.
- */
-declare class UndefinedValue extends RuntimeValue<undefined> {
-    type: string;
-}
-/**
- * Represents the current environment (scope) at runtime.
- */
-declare class Environment {
-    parent?: Environment | undefined;
-    /**
-     * The variables declared in this environment.
-     */
-    variables: Map<string, AnyRuntimeValue>;
-    /**
-     * The tests available in this environment.
-     */
-    tests: Map<string, (...value: AnyRuntimeValue[]) => boolean>;
-    constructor(parent?: Environment | undefined);
-    /**
-     * Set the value of a variable in the current environment.
-     */
-    set(name: string, value: unknown): AnyRuntimeValue;
-    private declareVariable;
-    /**
-     * Set variable in the current scope.
-     * See https://jinja.palletsprojects.com/en/3.0.x/templates/#assignments for more information.
-     */
-    setVariable(name: string, value: AnyRuntimeValue): AnyRuntimeValue;
-    /**
-     * Resolve the environment in which the variable is declared.
-     * @param {string} name The name of the variable.
-     * @returns {Environment} The environment in which the variable is declared.
-     */
-    private resolve;
-    lookupVariable(name: string): AnyRuntimeValue;
-}
-declare class Interpreter {
-    global: Environment;
-    constructor(env?: Environment);
-    /**
-     * Run the program.
-     */
-    run(program: Program): AnyRuntimeValue;
-    /**
-     * Evaluates expressions following the binary operation type.
-     */
-    private evaluateBinaryExpression;
-    private evaluateArguments;
-    /**
-     * Evaluates expressions following the filter operation type.
-     */
-    private evaluateFilterExpression;
-    /**
-     * Evaluates expressions following the test operation type.
-     */
-    private evaluateTestExpression;
-    /**
-     * Evaluates expressions following the unary operation type.
-     */
-    private evaluateUnaryExpression;
-    private evalProgram;
-    private evaluateBlock;
-    private evaluateIdentifier;
-    private evaluateCallExpression;
-    private evaluateSliceExpression;
-    private evaluateMemberExpression;
-    private evaluateSet;
-    private evaluateIf;
-    private evaluateFor;
-    /**
-     * See https://jinja.palletsprojects.com/en/3.1.x/templates/#macros for more information.
-     */
-    private evaluateMacro;
-    evaluate(statement: Statement | undefined, environment: Environment): AnyRuntimeValue;
-}
-
-declare function randomInt(to: number, from?: number): number;
-/**
- * Selects an element from the given object, array, or string.
- * @param obj Can be an object, array, or string to select from.
- * @param index Optional, specifies the index or key to select. Negative values indicate indices from the end.
- * @returns The selected element, or `undefined` if the input is empty or not provided.
- *
- * @example
- * // Selecting an element from an array
- * const array = ['apple', 'banana', 'cherry']
- * console.log(select(array)) // Random element from the array
- * console.log(select(array, 1)) // Second element
- * console.log(select(array, -1)) // Last element
- *
- * @example
- * // Selecting a property from an object
- * const obj = { fruit1: 'apple', fruit2: 'banana', fruit3: 'cherry' }
- * console.log(select(obj)) // Random property from the object
- * console.log(select(obj, 'fruit2')) // Property with key 'fruit2'
- *
- * @example
- * // Selecting a character from a string
- * const str = 'hello'
- * console.log(select(str)) // Random character from the string
- * console.log(select(str, 1)) // Second character
- * console.log(select(str, -1)) // Last character
- */
-declare function select(obj: any | any[], index?: number | string): any;
-declare 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;
-};
-
-/**
- * @file Jinja templating engine
- *
- * A minimalistic JavaScript reimplementation of the [Jinja](https://github.com/pallets/jinja) templating engine,
- * to support the chat templates. Special thanks to [Tyler Laceby](https://github.com/tlaceby) for his amazing
- * ["Guide to Interpreters"](https://github.com/tlaceby/guide-to-interpreters-series) tutorial series,
- * which provided the basis for this implementation.
- *
- * See the [Transformers documentation](https://huggingface.co/docs/transformers/main/en/chat_templating) for more information.
- *
- * @module index
- */
-
-declare class EnvironmentEx extends Environment {
-    parent?: EnvironmentEx | undefined;
-    constructor(parent?: EnvironmentEx | undefined);
-    assign(items: Record<string, unknown>): void;
-    clear(): void;
-}
-declare class Template {
-    parsed: Program;
-    static global: EnvironmentEx;
-    /**
-     * @param {string} template The template string
-     */
-    constructor(template: string, options?: PreprocessOptions);
-    render(items?: Record<string, unknown>): string;
-}
-
-declare class HfPromptTemplate extends PromptTemplate {
-    compiledTemplate: Template;
-    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean;
-    getVariables(template?: Template): string[];
-    _initialize(options?: PromptTemplateOptions): void;
-    _format(data: Record<string, any>): string;
-}
-declare function createHfValueFunc(fn: Function): (_data: any) => Function;
-
-/**
- * Type that represents a node in a parsed format string. It can be either
- * a literal text or a variable name.
- */
-type FStringPromptTemplateNode = {
-    type: "literal";
-    text: string;
-} | {
-    type: "variable";
-    name: string;
-};
-/**
- * Type that represents a function that takes a template string and
- * returns an array of `ParsedFStringNode`.
- *
- * extract from langchain.js/langchain-core/src/prompts/template.ts
- */
-declare function parseFString(template: string): FStringPromptTemplateNode[];
-/**
- * Type that represents a function that takes a template string and a set
- * of input values, and returns a string where all variables in the
- * template have been replaced with their corresponding values.
- */
-declare function interpolateFString(nodes: FStringPromptTemplateNode[], values: Record<string, any>): string;
-
-declare class FStringPromptTemplate extends PromptTemplate {
-    compiledTemplate: FStringPromptTemplateNode[];
-    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean;
-    getVariables(template?: FStringPromptTemplateNode[]): string[];
-    _initialize(options?: PromptTemplateOptions): void;
-    _format(data: Record<string, any>): string;
-}
-
-declare class GolangPromptTemplate extends PromptTemplate {
-    static isTemplate(templateOpt: PromptTemplateOptions | string): boolean | undefined;
-    getVariables(template: string): string[];
-    _initialize(options?: PromptTemplateOptions): void;
-    _format(data: Record<string, any>): string;
-}
-
-declare 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 {
+interface FewShotPromptTemplateOptions<T = any> extends StringTemplateOptions {
     /**
      * The few shot examples to use in the prompt.
      */
@@ -664,7 +226,7 @@ interface FewShotPromptTemplateOptions<T = any> extends PromptTemplateOptions {
     /**
      * An {@link PromptTemplate} used to format a single example.
      */
-    examplePrompt: PromptTemplate | PromptTemplateOptions;
+    examplePrompt: StringTemplate | StringTemplateOptions;
     /**
      * String separator used to join the prefix, the examples, and suffix.
      */
@@ -680,9 +242,9 @@ interface FewShotPromptTemplateOptions<T = any> extends PromptTemplateOptions {
      */
     suffix?: string;
 }
-declare class FewShotPromptTemplate<T = any> extends PromptTemplate {
+declare class FewShotPromptTemplate<T = any> extends StringTemplate {
     examples: PromptExamples<T>;
-    examplePrompt: PromptTemplate | undefined;
+    examplePrompt: StringTemplate | undefined;
     suffix: string;
     exampleSeparator: string;
     prefix: string;
@@ -693,103 +255,6 @@ declare class FewShotPromptTemplate<T = any> extends PromptTemplate {
     toJSON(options?: this): FewShotPromptTemplateOptions<T>;
 }
 
-/**
- * Parse and interpolate template
- * @param str golang style template
- * @param variables object of variables to insert
- */
-declare function interpolateGolangTemplate(str: string, variables: Record<string, any>, initVars?: boolean): string;
-
-declare function 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.
- * @param options.parsed Specify an object to provide the value of environment variables.
- *
- * Follows these rules to handle environment variable expansion:
- *
- * 1. Simple Variable Expansion: If a string contains `$KEY`, it will be replaced by the value of the environment variable named `KEY`.
- * 2. Braced Variable Expansion: When a string contains `${KEY}`, it also looks up the environment variable named `KEY`.
- *    This syntax is typically used to disambiguate variable names that contain special characters.
- * 3. Escaped Dollar Sign: If you want to include a literal `$` followed by a variable name, you can escape it with a backslash (`\$KEY`).
- *    This ensures the `$` character is treated as part of the literal string rather than a variable reference.
- * 4. Default Value: In the case of `${KEY:-default}` or `${KEY-default}`, the engine first tries to expand the KEY environment variable.
- *    If there's no such environment variable, it will use default as the fallback value.
- *
- * @example
- * const myEnv = {}
- * const env = {
- *   processEnv: myEnv,
- *   parsed: {
- *     WORD: 'World',
- *     HELLO: 'Hello ${WORD}'
- *   }
- * }
- * expandEnv.expand(env)
- *
- * console.log(myEnv.HELLO) // Hello World
- * console.log(process.env.HELLO) // undefined
- */
-declare function expandEnv(options: DotenvExpandOptions): DotenvExpandOptions;
-/**
- * Expands environment variables in an object/array or string.
- *
- * This function replaces placeholders like `${VAR}` in strings and recursively
- * processes objects and arrays with environment variable references.
- *
- * @param obj - The object/array or string to be processed. Can be any value, but
- *              primarily designed for objects, array and strings.
- * @param options - Configuration options:
- *   - processEnv: - An object to source environment variables from, defaults to `process.env`.
- *   - parsed: - Specify an object to provide the value of environment variables.
- * @returns - Returns the expanded object or string.
- *
- * @example
- * const obj = {
- *   name: 'MyApp',
- *   envVar: '${ENV_VAR_NAME}',
- *   config: {
- *     url: 'http://${HOST}:${PORT}'
- *   },
- *   list: ['item1', '${ITEM2}']
- * };
- * // the expandedObj will have the actual values instead of placeholders.
- * const expandedObj = expandObjEnv(obj, { processEnv: myCustomEnv }); // Assuming 'ENV_VAR_NAME' is defined as 'Production' and 'HOST', 'PORT', 'ITEM2' are set,
- *
- */
-declare function expandObjEnv(obj: any, options?: DotenvExpandOptions, parsedObjs?: WeakSet<any>): any;
-interface DotenvPopulateInput {
-    [name: string]: string | undefined;
-}
-interface DotenvParseInput {
-    [name: string]: string | undefined;
-}
-interface DotenvParseOutput {
-    [name: string]: string | undefined;
-}
-interface DotenvExpandOptions {
-    error?: Error;
-    /**
-     * Default: `process.env`
-     *
-     * Specify an object to write your secrets to. Defaults to process.env environment variables.
-     *
-     * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
-     */
-    processEnv?: DotenvPopulateInput;
-    /**
-     * Default: `object`
-     *
-     * Object coming from dotenv's parsed result.
-     */
-    parsed?: DotenvParseInput;
-}
-interface DotenvExpandOutput {
-    error?: Error;
-    parsed?: DotenvParseOutput;
-}
-
 interface SplitSentenceOptions {
     best?: boolean;
     completeSentence?: boolean;
@@ -871,7 +336,39 @@ declare function splitParagraph(value: string, options?: SplitSentenceOptions):
  */
 declare function truncTo(n: number, dec?: number, up?: number): number;
 
-declare function wait(ms: number): Promise<void>;
+/**
+ * Suspends execution for a specified number of milliseconds
+ * @param ms - The number of milliseconds to pause execution
+ * @example
+ * ```ts
+ * await sleep(500); // Pause for half a second
+ * ```
+ * @remarks
+ * This implementation uses `setTimeout` under the hood and is more precise
+ * for longer durations than `setImmediate`-based approaches
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * @alias sleep
+ * @deprecated Use {@link sleep} for clearer intent
+ *
+ * Legacy alias maintained for backward compatibility.
+ * Prefer the more explicit `sleep` naming in new code.
+ */
+declare const wait: typeof sleep;
+/**
+ * Yields execution control to the event loop, allowing pending I/O operations
+ * and scheduled tasks to run before continuing.
+ *
+ * @remarks
+ * This method creates a microtask checkpoint using `setImmediate`, which helps:
+ * - Interleave CPU-intensive work with I/O events
+ * - Prevent event loop blocking
+ * - Maintain application responsiveness
+ *
+ * Particularly useful for breaking up long synchronous operations in Node.js.
+ */
+declare function yieldExec(): Promise<void>;
 
 declare const EventName = "event";
 declare const EventBusName = "event-bus";
@@ -894,6 +391,85 @@ declare function getEventableClass(Backend: 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);
 
+type Events = (string | RegExp)[];
+/**
+ * Represents a client connected to the SSE channel.
+ */
+type Client = {
+    /** The incoming HTTP request from the client. */
+    req: IncomingMessage;
+    /** The server response object used to send events to the client. */
+    res: ServerResponse;
+    /** An array of event names or patterns that the client is subscribed to. */
+    events?: Events;
+    /**
+     * A unique identifier for the client.
+     * If not provided during subscription, it defaults to `remoteAddress:remotePort`.
+     */
+    clientId?: string;
+};
+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 data to the channel.
+     *
+     * @param data The data to send. Can be a string or a serializable object.
+     * @param eventName Optional name for the event.
+     * @param target Optional. If provided, the message will be sent only to clients with matching `clientId`s, bypassing event subscriptions.
+     * @returns The ID of the message, or `undefined` if no message was sent.
+     * @throws An error if the channel is closed.
+     */
+    publish(data?: string | Record<string, any>, eventName?: string, target?: {
+        clientId?: string | string[];
+    }): number | undefined;
+    /**
+     * Subscribes a client to the SSE channel.
+     *
+     * @param req The incoming HTTP request.
+     * @param res The server response.
+     * @param events An array of event names or patterns to subscribe to.
+     * @param clientId An optional unique ID for the client. If not provided, it defaults to `remoteAddress:remotePort`.
+     * @returns The newly created client object.
+     * @throws An error if the channel is closed.
+     */
+    subscribe(req: IncomingMessage, res: ServerResponse, events?: Events, clientId?: string): Client;
+    /**
+     * Unsubscribes a client from the SSE channel.
+     * @param 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 function isWebStream(val: any): val is ReadableStream<any> | WritableStream<any>;
 
 declare const RStreamErrCode = 600;
@@ -1044,93 +620,7 @@ interface HashAlgoParams {
 }
 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.
- * do not use /g global option here: when the regex is executed multiple times, it will always begin where it left off last time.
- */
-declare const FilenameReservedRegex: RegExp;
-/**
- * Regular expression pattern for reserved names on Windows systems.
- */
-declare const WindowsReservedNameRegex: RegExp;
-/**
- * Returns a new regular expression instance for reserved filename characters with the 'g' flag.
- * use this to reset the with global option
- * @returns A compiled regular expression for reserved filename characters.
- */
-declare function filenameReservedRegex(): RegExp;
-/**
- * Returns a new regular expression instance for control characters in a filename with the 'g' flag.
- * @returns A compiled regular expression for control characters in a filename.
- */
-declare function reControlCharsRegex(): RegExp;
-/**
- * Validates if a given string is a valid filename.
- * @param {string} filename - The filename to be validated.
- * @returns True if the filename is valid, false otherwise.
- * @throws {TypeError} If the input is not a string.
- * @example
-* isValidFilename('myFile.txt'); // Returns true
-* isValidFilename('my<file.txt'); // Returns false
-*/
-declare function isValidFilename(filename: string): boolean | "";
-/**
- * Validates whether the given filepath is valid.
- * @param filepath - The filepath to be checked, represented as a string.
- * @returns A boolean indicating whether the filepath is valid. Returns true if valid; false otherwise.
- */
-declare function isValidFilepath(filepath: string): boolean;
-interface SanitizeFilenameOptions {
-    replacement?: string;
-    maxLength?: number;
-}
-/**
- * Sanitizes a given filename by replacing invalid characters with a specified replacement character or a default.
- * @param filename - The filename to sanitize, represented as a string.
- * @param options - An optional object containing configuration options:
- *   - `replacement` {string} - The character to replace invalid characters with. Default is '!'. Cannot contain reserved filename characters.
- *   - `maxLength` {number} - The maximum length of the sanitized filename. Default is `MAX_FILENAME_LENGTH`.
- * @returns The sanitized filename.
- * @throws {Error} - If the `replacement` contains reserved filename characters or control characters.
- */
-declare function sanitizeFilename(filename: string, options?: SanitizeFilenameOptions): string;
-/**
- * Sanitizes each part of a file path and reassembles it, ensuring the path is valid according to provided options.
- * @param filepath - The file path to sanitize, represented as a string.
- * @param options - Optional settings for sanitization, extending `SanitizeFilenameOptions`. Allows customization of replacement characters and maximum filename length.
- * @returns The sanitized file path as a string.
- */
-declare function sanitizeFilepath(filepath: string, options?: SanitizeFilenameOptions): string;
-/**
- * Retrieves multi-level file extension
- * @param filename The file name
- * @param level The level, default is 1, indicating the number of extension levels to retrieve
- * @returns Returns a concatenated string of multiple extensions, or an empty string if no extension is found
- */
-declare function getMultiLevelExtname(filename: string, level?: number): string;
-/**
- * Calculates the level of an extension name.
- *
- * The level represents the number of dots ('.') in the extension name, excluding the first dot which separates
- * the base filename from the extension. For example, the level of ".txt" is 1, and the level of ".tar.gz" is 2.
- *
- * @param extName - The extension name to analyze. It should start with a dot ('.').
- * @returns The level of the extension name, which is the count of dots minus one.
- *
- * @example
-* ```typescript
-* // Returns 0
-* extNameLevel("no-file-ext");
-*
-* // Returns 2
-* extNameLevel(".tar.gz");
-*
-* // Returns 1
-* extNameLevel(".json5");
-* ```
-*/
-declare function extNameLevel(extName: string): number;
+declare function hashObject(value: any, options?: HashAlgoParams): Promise<string | Uint8Array<ArrayBufferLike>>;
 
 /**
  * Checks if the provided model name matches the given rule.
@@ -1235,6 +725,7 @@ declare function decodeCharset(result: Buffer, encoding?: BufferEncoding): strin
  * @param dir - A single directory path or an array of directory paths to start the search from.
  * @param options.isFileMatched - An optional callback that determines whether a file should be included in the result.
  * @param options.signal - An optional signal to abort the operation.
+ * @param options.resolveSymlinks - Whether to resolve symbolic links to their real paths. Defaults to true.
  * @returns An array of file paths that match the criteria.
  *
  * @example
@@ -1247,6 +738,7 @@ declare function readFilenamesRecursiveSync(dir: string | string[], options?: {
     isFileMatched?: (filepath: string, file: fs.Dirent | fs.Stats) => boolean;
     signal?: AbortSignal;
     level?: number;
+    resolveSymlinks?: boolean;
 }): string[];
 /**
  * Resolves the real file path, handling symbolic links.
@@ -1275,10 +767,6 @@ declare function getFileMetaInfo(filepath: string): Promise<IFileMetaInfo>;
 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, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
-declare function stringifyYaml(content: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions): string;
-
 interface ConfigFilesFilter {
     after?: {
         [filepath: string]: number;
@@ -1358,8 +846,11 @@ declare function jsonToMarkdownStr(mem: any, options?: {
     visiting?: Set<any>;
     objectTag?: string;
     arrayTag?: string;
+    parent?: any;
+    title?: string | boolean;
 }): string;
 
+declare function DefaultDateFormat(format?: string): string;
 declare function toDateTime(date: Date | string | number): Date | undefined;
 declare function textToDate(date: string, format?: string): Date;
 declare function dateToText(date: Date, format?: string): string;
@@ -1627,7 +1118,7 @@ declare function getPackageDir(cwd: string): string;
  *
  * @param parentDir - The directory to check as the potential parent.
  * @param childDir - The directory to check as the potential child.
- * @returns true if `childDir` is a subdirectory of `parentDir`, otherwise false.
+ * @returns true if `childDir` is a subdirectory of `parentDir` or same folder, otherwise false.
  *
  * @example
 * ```typescript
@@ -1657,11 +1148,44 @@ declare function hasDirectoryIn(dir: string, dirs?: string[]): boolean | undefin
  * @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;
-
-declare function stripConsoleColor(str: any): any;
-
+/**
+ * Filters out subdirectories from the given array of paths, keeping only the top-level (parent) directories.
+ *
+ * @param paths - An array of directory paths.
+ * @returns A new array containing only the paths that are not subdirectories of any other path in the input.
+ *
+ * @example
+ * ```ts
+ * const paths = ['/usr/local', '/usr/local/include', '/home/user/project'];
+ * const result = pruneSubdirectories(paths);
+ * // result: ['/usr/local', '/home/user/project']
+ * ```
+ */
+declare function pruneSubdirectories(paths: string[]): string[];
+/**
+ * Filters out subdirectories from the given array of paths in-place, keeping only the top-level (parent) directories.
+ *
+ * This function helps organize file paths by:
+ * * Removing any subfolders that are completely contained within other folders
+ * * Preserving the original order of paths you added
+ * * Eliminating duplicate paths
+ *
+ * @param paths - Array of directory paths to clean (can mix different OS path formats)
+ *
+ * @example
+ * ```ts
+ * let paths = ['/usr/local', '/usr/local/include', '/home/user/project'];
+ * pruneSubdirectoriesInPlace(paths);
+ * // paths is now: ['/usr/local', '/home/user/project']
+ * ```
+ */
+declare function pruneSubdirectoriesInPlace(paths: string[]): void;
+declare function normalizePath(inputPath: string): string;
+
+declare function isRegExp(value: any): boolean;
+
+declare function stripConsoleColor(str: any): any;
+
 declare const LLM_TOKENIZER_NAMES: {
     'deepseek-ai/DeepSeek-V2-Lite-Chat': string;
     'Qwen/Qwen2.5-0.5B': string;
@@ -1746,6 +1270,175 @@ declare function truncateToTokenLimit(content: string, options?: ITruncateToToke
 declare function truncateToTokenLimitEx(sentences: string[], options?: ITruncateToTokenLimitOptions): Promise<string[]>;
 declare function truncateByToken(content: string, options?: ITruncateToTokenLimitOptions): Promise<void>;
 
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<BaseType extends object> =
+	BaseType extends unknown // For distributing `BaseType`
+		? (keyof {
+			[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
+		}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+		: never; // Should never happen
+
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<BaseType extends object> =
+	BaseType extends unknown // For distributing `BaseType`
+		? Exclude<keyof BaseType, OptionalKeysOf<BaseType>>
+		: never; // Should never happen
+
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+// Can eventually be replaced with the built-in once this library supports
+// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
+type NoInfer<T> = T extends infer U ? U : never;
+
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -1778,6 +1471,377 @@ type IsEqual<A, B> =
 		? true
 		: false;
 
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};
+
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? KeyType
+		: never]: ObjectType[KeyType];
+};
+
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+}
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@category Object
+*/
+type Merge<Destination, Source> =
+Simplify<
+SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
+& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
+>;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `any`.
+
+@see {@link IsAny}
+
+@example
+```
+import type {IfAny} from 'type-fest';
+
+type ShouldBeTrue = IfAny<any>;
+//=> true
+
+type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
+	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
+);
+
+// Should never happen
+
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+*/
+type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
+	IsAny<T> extends true
+		? IfAny
+		: IsNever<T> extends true
+			? IfNever
+			: IfNotAnyOrNever;
+
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<
+	Options extends object,
+	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
+	SpecifiedOptions extends Options,
+> =
+	IfAny<SpecifiedOptions, Defaults,
+	IfNever<SpecifiedOptions, Defaults,
+	Simplify<Merge<Defaults, {
+		[Key in keyof SpecifiedOptions
+		as Key extends OptionalKeysOf<Options>
+			? Extract<SpecifiedOptions[Key], undefined> extends never
+				? Key
+				: never
+			: Key
+		]: SpecifiedOptions[Key]
+	}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+	>>;
+
 /**
 Filter out keys from an object.
 
@@ -1818,6 +1882,10 @@ type ExceptOptions = {
 	requireExactProps?: boolean;
 };
 
+type DefaultExceptOptions = {
+	requireExactProps: false;
+};
+
 /**
 Create a type from an object type without certain keys.
 
@@ -1847,11 +1915,34 @@ type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
 
 const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 //=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; [x: number]: string; }
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayload = Except<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
 @category Object
 */
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
+	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
 	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
 } & (Options['requireExactProps'] extends true
 	? Partial<Record<KeysType, never>>
@@ -1881,6 +1972,16 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 type RequireAtLeastOne<
 	ObjectType,
 	KeysType extends keyof ObjectType = keyof ObjectType,
+> =
+	IfNotAnyOrNever<ObjectType,
+	IfNever<KeysType,
+	never,
+	_RequireAtLeastOne<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
+	>>;
+
+type _RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType,
 > = {
 	// For each `Key` in `KeysType` make a mapped type:
 	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
@@ -1950,7 +2051,7 @@ 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 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): {
@@ -1960,6 +2061,8 @@ declare function getXDGConfigs(config: Config): {
     XDG_BIN_HOME: string;
 };
 declare function expandPath(path: string, config?: any): any;
+declare function expandPaths(paths: string[], config?: any): any[];
+declare function expandPathInObject(obj: any, pathKeys?: string[], config?: any): void;
 
 /**
  * @callback BeforeShutdownListener
@@ -1991,4 +2094,334 @@ declare function shutdown(signalOrEvent?: string | number, exitCode?: number | s
 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 };
+interface ProbabilityItem {
+    /**
+     * The id of the token.
+     */
+    id?: number;
+    /**
+     * The token string being analyzed
+     */
+    token: string;
+    /**
+     * The natural logarithm of the probability (log probability) assigned to this token.
+     * Using log probabilities helps prevent numerical underflow when multiplying
+     * many small probabilities together in language model calculations.
+     *
+     */
+    probability: number;
+}
+interface CalcPerplexityExcludeOptions {
+    controlSymbols?: boolean;
+    punctuation?: boolean;
+    whitespace?: boolean;
+    stopWords?: boolean;
+    tokens?: string[];
+}
+interface CalcPerplexityOptions {
+    exclude?: CalcPerplexityExcludeOptions;
+}
+/**
+ * Calculates the perplexity of a given list of probability items.
+ * Perplexity is a measurement used in natural language processing (NLP)
+ * to evaluate the quality of a language model. Lower perplexity indicates
+ * better predictions made by the model.
+ *
+ * @param probabilities - An array of `ProbabilityItem` objects, each containing
+ *                        a token and its associated probability.
+ * @param options - Optional configuration for excluding specific types of tokens
+ *                  from the calculation.
+ * @returns The calculated perplexity value as a number.
+ *
+ * @example
+ * ```typescript
+ * const probabilities = [
+ *   { token: "hello", probability: 0.1 },
+ *   { token: "world", probability: 0.05 },
+ *   { token: "<EOS>", probability: 0.02 },
+ *   { token: ",", probability: 0.01 }
+ * ];
+ *
+ * // Exclude control symbols and punctuation from the calculation
+ * const options = {
+ *   exclude: {
+ *     controlSymbols: true,
+ *     punctuation: true
+ *   }
+ * };
+ *
+ * const perplexity = calcPerplexity(probabilities, options);
+ * console.log(perplexity); // Outputs the calculated perplexity value
+ * ```
+ */
+declare function calcPerplexity(probabilities: ProbabilityItem[], options?: CalcPerplexityOptions): number | undefined;
+/**
+ * A simplified version of the perplexity calculation function.
+ * This function directly calculates the perplexity from an array
+ * of `ProbabilityItem` objects without any token exclusion options.
+ *
+ * @param probabilities - An array of `ProbabilityItem` objects, each containing
+ *                        a token and its associated probability.
+ * @returns The calculated perplexity value as a number.
+ *
+ * @example
+* ```typescript
+* const probabilities = [
+*   { token: "hello", probability: 0.1 },
+*   { token: "world", probability: 0.05 }
+* ];
+*
+* const perplexity = calcPerplexitySimple(probabilities);
+* console.log(perplexity); // Outputs the calculated perplexity value
+* ```
+*/
+declare function calcPerplexitySimple(probabilities: ProbabilityItem[]): number | undefined;
+
+declare const ArrayMergeWaySymbol: unique symbol;
+declare const ArrayMergeWay: {
+    readonly replace: 0;
+    readonly start: 1;
+    readonly end: 2;
+};
+type ArrayMergeWay = typeof ArrayMergeWay[keyof typeof ArrayMergeWay];
+/**
+ * Merges multiple source objects into the target object with a custom merging strategy.
+ *
+ * @param target The target object, whose properties will be overridden or merged by source object values.
+ * @param source Source objects, whose properties will be merged into the target object.
+ * @returns The merged target object.
+ *
+ * This function performs deep merging using the following rules:
+ * - For non-array properties, standard deep merging is applied.
+ * - For arrays, a custom merging strategy is used based on the first element of the target array:
+ *   - **`@inheritMerge(.start)`** or no marker: Prepend the target array to the source array. defaults to this.
+ *   - **`@inheritMerge(.end)`**: Append the source array to the end of the target array.
+ *   - **`@inheritMerge(false)`**, **`@inheritMerge(no)`**, or **`@inheritMerge(not)`**: Replace the target array with the source array.
+ *
+ * @example
+ * ```typescript
+ * // Example 1: Default behavior (.start)
+ * const target = {
+ *   items: ['item1', 'item2']
+ * };
+ * const source = {
+ *   items: ['item3', 'item4']
+ * };
+ * console.log(defaultsWithConcat(target, source).items);
+ * // Output: ['item3', 'item4', 'item1', 'item2']
+ *
+ * // Example 2: Append behavior (.end)
+ * const target = {
+ *   items: ['@inheritMerge(.end)', 'item1', 'item2']
+ * };
+ * const source = {
+ *   items: ['item3', 'item4']
+ * };
+ * console.log(defaultsWithConcat(target, source).items);
+ * // Output: ['item1', 'item2', 'item3', 'item4']
+ *
+ * // Example 3: Replace behavior (false)
+ * const target = {
+ *   items: ['@inheritMerge(false)', 'item1', 'item2']
+ * };
+ * const source = {
+ *   items: ['item3', 'item4']
+ * };
+ * console.log(defaultsWithConcat(target, source).items);
+ * // Output: ['item3', 'item4']
+ * ```
+ */
+declare function defaultsWithConcat(target: any, ...source: any[]): any;
+/**
+ * Merges two arrays based on a custom strategy defined by the first element of the target array.
+ *
+ * The first element of the target array can contain a special marker (`@inheritMerge`) to control the merging behavior:
+ * - `@inheritMerge(false)` or `@inheritMerge(no)` or `@inheritMerge(not)`: Replace the target array with the source array.
+ * - `@inheritMerge(.end)`: Append the source array to the end of the target array.
+ * - `@inheritMerge(.start)` or no marker: Prepend the target array to the source array.
+ *
+ * @param targetArr The target array to be merged.
+ * @param srcArr The source array to merge into the target array.
+ * @returns The merged array based on the specified strategy.
+ *
+ * @example
+ * ```typescript
+ * // Example 1: Default behavior (.start)
+ * const target = ['item1', 'item2'];
+ * const source = ['item3', 'item4'];
+ * console.log(mergeArray(target, source)); // Output: ['item3', 'item4', 'item1', 'item2']
+ *
+ * // Example 2: Append behavior (.end)
+ * const target = ['@inheritMerge(.end)', 'item1', 'item2'];
+ * const source = ['item3', 'item4'];
+ * console.log(mergeArray(target, source)); // Output: ['item1', 'item2', 'item3', 'item4']
+ *
+ * // Example 3: Replace behavior (false)
+ * const target = ['@inheritMerge(false)', 'item1', 'item2'];
+ * const source = ['item3', 'item4'];
+ * console.log(mergeArray(target, source)); // Output: ['item3', 'item4']
+ * ```
+ */
+declare function mergeArray(targetArr: any[], srcArr: any[]): any[];
+
+/**
+ * Splits a string into words using splitWords rules, then joins them with a separator
+ *
+ * This is a convenience function that combines word splitting and joining operations.
+ * It's useful for converting camelCase, PascalCase, or mixed-alphanumeric strings
+ * into human-readable formats with custom separators.
+ *
+ * @param input - The string to process
+ * @param separator - The separator to use when joining words (default: space)
+ * @returns The input string with words separated by the specified delimiter
+ *
+ * @example
+ * joinSplitWords("HelloWorld")            // Returns "Hello World"
+ * joinSplitWords("item1label21Good", "-") // Returns "item1-label21-Good"
+ * joinSplitWords("HTTPRequest", "_")      // Returns "HTTP_Request"
+ * joinSplitWords("Good morning", "-")          // Returns "Good-morning"
+ */
+declare function joinSplitWords(input: string, separator?: string): string;
+/**
+ * Splits a string into an array of words based on case changes, digit boundaries, and spaces.
+ *
+ * This function identifies word boundaries using the following rules:
+ * 1. Between a lowercase letter followed by an uppercase letter (camelCase)
+ * 2. Between a digit and a letter (alphanumeric boundaries)
+ * 3. Between consecutive uppercase letters when followed by a lowercase letter (acronyms)
+ * 4. At whitespace characters
+ *
+ * @param input - The string to be split into words
+ * @returns An array of words extracted from the input string
+ *
+ * @example
+ * splitWords("HelloWorld")     // Returns ["Hello", "World"]
+ * splitWords("item1label21Good") // Returns ["item1", "label21", "Good"]
+ * splitWords("HTTPRequest")    // Returns ["HTTP", "Request"]
+ * splitWords("Good morning")   // Returns ["Good", "morning"]
+ */
+declare function splitWords(input: string): string[];
+
+/**
+ * Utility to serialize an object into a URL query parameter string.
+ * @param {any} objParam - The parameter object.
+ * @returns {string} The URL-encoded query string or an empty string.
+ */
+declare function genUrlParamsStr(objParam: any): string;
+
+declare class SseServerPubSubTransport implements IPubSubServerTransport {
+    readonly name = "sse";
+    readonly protocol: "sse";
+    private channel;
+    private onConn?;
+    private onDis?;
+    mount?(): void;
+    subscribe(events?: string[], options?: {
+        req?: IncomingMessage;
+        res?: ServerResponse;
+        clientId?: string;
+    }): {
+        req: IncomingMessage;
+        res: ServerResponse;
+        events?: (string | RegExp)[];
+        clientId?: string;
+    };
+    publish(event: string, data: any, target?: {
+        clientId?: PubSubClientId | PubSubClientId[];
+    }): void;
+    onConnection(cb: (s: PubSubServerSession) => void): void;
+    onDisconnect(cb: (s: PubSubServerSession) => void): void;
+}
+
+declare class SseClientPubSubTransport implements IPubSubClientTransport {
+    connect(url: string, params?: Record<string, any>): PubSubClientStream;
+    disconnect(stream: PubSubClientStream): void;
+}
+
+/**
+ * Defines the public interface for a server-side transport,
+ * responsible for exposing ServerTools to the network.
+ */
+interface IServerToolTransport extends IToolTransport {
+    /**
+     * Mounts the ServerTools registry, creating the necessary API routes.
+     * @param serverTools The ServerTools class.
+     * @param apiPrefix An optional prefix for all API routes.
+     * @param options Additional options for the transport start.
+     */
+    mount(serverTools: typeof ServerTools, apiPrefix?: string, options?: any): void;
+    /**
+     * Starts the transport layer, making it listen for incoming connections.
+     * @param options Protocol-specific options (e.g., { port, host }).
+     */
+    start(options?: any): Promise<any>;
+    /**
+     * Stops the server instance gracefully.
+     * @param force - Optional flag to force shutdown immediately
+     * @returns Promise<void> when server is fully stopped
+     */
+    stop(force?: boolean): Promise<void>;
+    /**
+     * Gets the underlying raw server instance.
+     */
+    getRaw?(): any;
+}
+/**
+ * An abstract base class for server-side transport implementations.
+ * It provides the generic tool-mounting logic.
+ */
+declare abstract class ServerToolTransport extends ToolTransport implements IServerToolTransport {
+    apiRoot: string;
+    Tools: typeof ServerTools;
+    options?: any;
+    _mount(Tools: typeof ServerTools, apiPrefix: string, options?: any): void;
+    start(options?: any): Promise<any>;
+    abstract addDiscoveryHandler(path: string, handler: () => any): void;
+    abstract addRpcHandler(serverTools: typeof ServerTools, apiPrefix: string, options?: any): void;
+    abstract _start(options?: any): Promise<any>;
+    abstract stop(force?: boolean): Promise<void>;
+    abstract getRaw?(): any;
+}
+
+/**
+ * A concrete server transport implementation using Node.js's built-in HTTP server.
+ */
+declare class HttpServerToolTransport extends ServerToolTransport {
+    server: http.Server;
+    private discoveryHandlerInfo;
+    private rpcHandlerInfo;
+    constructor(options?: http.ServerOptions);
+    private requestListener;
+    addDiscoveryHandler(apiPrefix: string, handler: () => any): void;
+    addRpcHandler(serverTools: typeof ServerTools, apiPrefix: string, options?: any): void;
+    private handleRpcRequest;
+    private getRequestBody;
+    _start(options: {
+        port: number;
+        host?: string;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    getRaw(): http.Server;
+}
+
+/**
+ * A concrete client transport implementation that uses the browser/node `fetch` API.
+ */
+declare class HttpClientToolTransport extends ClientToolTransport {
+    /**
+     * Connects to the server's discovery endpoint to get the list of available tools.
+     * @returns A promise that resolves to a map of tool function metadata.
+     */
+    loadApis(): Promise<Funcs>;
+    _fetch(name: string, args?: any, act?: ActionName | string, subName?: any, fetchOptions?: any): Promise<Response>;
+    /**
+     * @internal
+     * A helper to create a structured error from a failed `fetch` response.
+     * @param res - The HTTP response.
+     * @returns A structured error object.
+     */
+    errorFrom(name: string, res: Response): Promise<_isdk_common_error.CommonError>;
+    toObject(res: any, args?: any): Promise<any>;
+}
+
+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, ActionName, ArrayMergeWay, ArrayMergeWaySymbol, AsyncTaskId, type BeforeShutdownListener, ChoiceArgProcessor, ClientToolTransport, DEFAULT_CONFIG_NAME, DefaultDateFormat, EventBusName, type EventErrorListenerFn, type EventListenerFn, EventName, FewShotPromptTemplate, type FewShotPromptTemplateOptions, Funcs, type HashAlgoParams, HashAlgorithm, HttpClientToolTransport, HttpServerToolTransport, type IFileMetaInfo, IPubSubClientTransport, IPubSubServerTransport, type IReadTextFileChunksOptions, type IServerToolTransport, IToolTransport, type ITruncateToTokenLimitOptions, IntSet, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, ObjectArgsToArgsInfo, type ParseObjectArgumentOptions, type ProbabilityItem, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PubSubClientId, PubSubClientStream, PubSubServerSession, RStreamErrCode, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, SHUTDOWN_SIGNALS, SSEChannel, SSEChannelAlreadyClosedErrCode, type SectionStringOptions, ServerToolTransport, ServerTools, SignalGate, type SplitSentenceOptions, SseClientPubSubTransport, SseServerPubSubTransport, StrangeHumanName, type StreamCallbacksAndOptions, TemplateArgProcessor, ToolTransport, YamlTypeBaseObject, assignDirs, backendEventable, base32768, beforeShutdown, calcPerplexity, calcPerplexitySimple, completeSentences, concatText, countLLMTokens, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createYamlObjectTag, dateToText, decodeCharset, defaultsWithConcat, detectCharset, encodeLLMTokens, ensureQuoted, expandConfig, expandPath, expandPathInObject, expandPaths, fileIsExists, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, genUrlParamsStr, getAllEnumKeys, getConfigFileNames, getConfigs, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getPackageDir, getRealFilepath, getResponseErrorReadableStream, getXDGConfigs, hasDirectoryIn, hash, hashFile, hashObject, hashStream, initShutdown, isLangUsingSpaces, isListItemString, isModelNameMatched, isPunctuationChar, isQuoted, isRegExp, isSameString, isSectionString, isSentenceEnding, isSepLineString, isStrWrapped, isSubdirectory, isTitleString, isWebStream, joinSplitWords, jsonFilterToWhere, jsonToMarkdownStr, loadAIConfig, loadConfig, loadConfigFile, loadFileFromPaths, loadTextFromPaths, matchUrlProtocol, memoize, mergeArray, messagesToText, normalizePath, paramsSizeToScaleStr, parseCommand, parseJsJson, parseJsJsonSimpleSync, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, pruneSubdirectories, pruneSubdirectoriesInPlace, quoteStr, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, saveConfigFile, scaleStrToParamsSize, shutdown, simplifyObjectArguments, sleep, sortedValues, splitChunks, splitParagraph, splitSentence, splitWords, stripConsoleColor, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, truncateByToken, truncateToTokenLimit, truncateToTokenLimitEx, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr, yieldExec };