@isdk/ai-tool 0.6.0 → 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 { 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 _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 { 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 {
@@ -334,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";
@@ -357,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;
@@ -507,6 +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>>;
+declare function hashObject(value: any, options?: HashAlgoParams): Promise<string | Uint8Array<ArrayBufferLike>>;
 
 /**
  * Checks if the provided model name matches the given rule.
@@ -732,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;
@@ -1001,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
@@ -1031,6 +1148,39 @@ 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[];
+/**
+ * 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;
 
@@ -1120,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.
 
@@ -1152,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.
 
@@ -1192,6 +1882,10 @@ type ExceptOptions = {
 	requireExactProps?: boolean;
 };
 
+type DefaultExceptOptions = {
+	requireExactProps: false;
+};
+
 /**
 Create a type from an object type without certain keys.
 
@@ -1221,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>>
@@ -1255,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
@@ -1334,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
@@ -1365,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, EventBusName, type EventErrorListenerFn, type EventListenerFn, EventName, FewShotPromptTemplate, type FewShotPromptTemplateOptions, type HashAlgoParams, HashAlgorithm, type IFileMetaInfo, type IReadTextFileChunksOptions, type ITruncateToTokenLimitOptions, IntSet, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, ObjectArgsToArgsInfo, type ParseObjectArgumentOptions, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, RStreamErrCode, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, SHUTDOWN_SIGNALS, type SectionStringOptions, SignalGate, type SplitSentenceOptions, type StreamCallbacksAndOptions, TemplateArgProcessor, YamlTypeBaseObject, assignDirs, backendEventable, base32768, beforeShutdown, completeSentences, concatText, countLLMTokens, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createYamlObjectTag, dateToText, decodeCharset, detectCharset, encodeLLMTokens, ensureQuoted, expandConfig, expandPath, fileIsExists, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, getAllEnumKeys, getConfigFileNames, getConfigs, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getPackageDir, getRealFilepath, getResponseErrorReadableStream, getXDGConfigs, hasDirectoryIn, hash, hashFile, hashStream, initShutdown, isLangUsingSpaces, isListItemString, isModelNameMatched, isPunctuationChar, isQuoted, isRegExp, isSameString, isSectionString, isSentenceEnding, isSepLineString, isStrWrapped, isSubdirectory, isTitleString, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadAIConfig, loadConfig, loadConfigFile, loadFileFromPaths, loadTextFromPaths, matchUrlProtocol, memoize, messagesToText, paramsSizeToScaleStr, parseCommand, parseJsJson, parseJsJsonSimpleSync, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, quoteStr, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, saveConfigFile, scaleStrToParamsSize, shutdown, simplifyObjectArguments, sortedValues, splitChunks, splitParagraph, splitSentence, 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 };