@isdk/ai-tool 0.2.3 → 0.3.0

package/dist/index.d.ts

@@ -2,15 +2,17 @@ import * as custom_ability from 'custom-ability';
 import { AbilityOptions } from 'custom-ability';
 export { createAbilityInjector } from 'custom-ability';
 export { toRegExp } from 'util-ex';
-import { A as AsyncFeatures, T as ToolFunc, a as AIModelNameRules } from './index-DUEs7T8M.js';
-export { e as AIModelNameRule, d as AIModelNameRuleFn, c as ActionName, b as ActionNames, k as AsyncFeatureBits, p as BaseFunc, B as BaseFuncItem, C as ClientFuncItem, u as ClientToolFuncSchema, t as ClientTools, J as EventClient, I as EventClientFuncParams, M as EventServer, L as EventServerFuncParams, E as EventToolFunc, o as FuncItem, l as FuncParam, F as FuncParamType, m as FuncParams, q as Funcs, P as PASSING_SCORE, f as RemoteFuncItem, R as RemoteToolFuncSchema, O as ResClientFuncParams, Q as ResClientTools, U as ResServerFuncParams, V as ResServerTools, g as SSEChannel, S as SSEChannelAlreadyClosedErrCode, w as ServerFuncItem, v as ServerFuncParams, y as ServerToolFuncSchema, x as ServerTools, n as TFunc, i as ToolAsyncCancelableBit, h as ToolAsyncMultiTaskBit, j as ToolAsyncPriorityBit, r as ToolFuncPackage, s as ToolFuncSchema, _ as _lrucache, G as createLRUCache, D as event, K as eventClient, N as eventServer, H as lrucache, z as registerCoreTools } from './index-DUEs7T8M.js';
+import { A as AsyncFeatures, T as ToolFunc, a as AIModelNameRules } from './index-BC3GQn6-.js';
+export { e as AIModelNameRule, d as AIModelNameRuleFn, c as ActionName, b as ActionNames, k as AsyncFeatureBits, p as BaseFunc, B as BaseFuncItem, C as ClientFuncItem, u as ClientToolFuncSchema, t as ClientTools, J as EventClient, I as EventClientFuncParams, M as EventServer, L as EventServerFuncParams, E as EventToolFunc, o as FuncItem, l as FuncParam, F as FuncParamType, m as FuncParams, q as Funcs, P as PASSING_SCORE, f as RemoteFuncItem, R as RemoteToolFuncSchema, O as ResClientFuncParams, Q as ResClientTools, U as ResServerFuncParams, V as ResServerTools, g as SSEChannel, S as SSEChannelAlreadyClosedErrCode, w as ServerFuncItem, v as ServerFuncParams, y as ServerToolFuncSchema, x as ServerTools, n as TFunc, i as ToolAsyncCancelableBit, h as ToolAsyncMultiTaskBit, j as ToolAsyncPriorityBit, r as ToolFuncPackage, s as ToolFuncSchema, _ as _lrucache, G as createLRUCache, D as event, K as eventClient, N as eventServer, H as lrucache, z as registerCoreTools } from './index-BC3GQn6-.js';
 import { CommonError, BaseError } from '@isdk/common-error';
 export { AbortError, AbortErrorCode, AlreadyExistsError, AlreadyExistsErrorCode, BaseError, CommonError, ErrorCode, InternalErrorCode, NotFoundError, NotFoundErrorCode, NotImplementationError, NotImplementedErrorCode, createError, throwError } from '@isdk/common-error';
 import { BaseFactory } from 'custom-factory';
 import { Event } from 'events-ex';
 import * as _base32768 from 'base32768';
+import * as fs from 'fs';
 import _memoize, { Options } from 'memoizee';
 export { f as findPort } from './find-port-qS1CZ9c-.js';
+import { PreTrainedTokenizer } from '@xenova/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';
@@ -261,6 +263,9 @@ type AIChatRole = (typeof AIChatRoles[number]) & string;
 type AIChatMessageParam = AIChatSystemMessageParam | AIChatUserMessageParam | AIChatAssistantMessageParam | AIChatToolMessageParam;
 interface AIChatMessageParamBase {
     role: string;
+    toRole?: string | string[] | Record<string, Partial<AIChatMessageParam>>;
+    replies?: Record<string, Partial<AIChatMessageParam>>;
+    private?: boolean;
     [name: string]: any;
 }
 interface AIChatSystemMessageParam extends AIChatMessageParamBase {
@@ -959,6 +964,12 @@ interface DotenvExpandOutput {
     parsed?: DotenvParseOutput;
 }
 
+interface SplitSentenceOptions {
+    best?: boolean;
+    completeSentence?: boolean;
+    isMarkdown?: boolean;
+    ignoreEmptyLine?: boolean;
+}
 /**
  * Splits a text into sentences.
  * This function is used to split a text into separate sentences, based on punctuation marks such as '.', '?', or '!' and other rules.
@@ -971,7 +982,49 @@ interface DotenvExpandOutput {
  * const text = "Hello world! How are you today? I am fine.";
  * console.log(splitSentence(text));  // returns ['Hello world!', 'How are you today?', 'I am fine.']
  */
-declare function splitSentence(text: string, best?: boolean): string[];
+declare function splitSentence(text: string, { best, completeSentence, isMarkdown, ignoreEmptyLine }?: SplitSentenceOptions): string[];
+declare function completeSentences(sentences: string[], { isMarkdown, ignoreEmptyLine }?: SplitSentenceOptions): string[];
+declare function concatText(left: string, right: string): string;
+declare function isSentenceEnding(text: string): boolean;
+interface SectionStringOptions {
+    isMarkdown?: boolean;
+    nextLine?: string;
+}
+declare function isSectionString(text: string, options?: SectionStringOptions): RegExpExecArray | null;
+declare function isTitleString(text: string, options?: SectionStringOptions): RegExpExecArray | null;
+declare function isListItemString(text: string): RegExpExecArray | null;
+declare function isSepLineString(text: string): RegExpExecArray | null;
+/**
+ * Checks if the given character is a punctuation mark.
+ * This function supports both Chinese and English punctuation marks.
+ *
+ * @param char - The character to check.
+ * @returns `true` if the character is a punctuation mark, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * isPunctuationChar('。'); // returns true
+ * isPunctuationChar('!');  // returns true
+ * isPunctuationChar('a');  // returns false
+ * ```
+ */
+declare function isPunctuationChar(char: string): boolean;
+declare function isLangUsingSpaces(isoCode: string): boolean;
+declare function findIndexNonEmptyFrom(arr: any[], start?: number): number;
+declare function removeMarkdownBold(s: string, once?: boolean): string;
+declare function removeMarkdownItalic(s: string, once?: boolean): string;
+declare function removeMarkdownBoldAndItalic(s: string, once?: boolean): string;
+
+/**
+ * Splits the input string into paragraphs based on empty lines and title lines.
+ * Each paragraph is represented as an array of strings, where each string is a line in the paragraph.
+ *
+ * @param value - The input string to be split into paragraphs.
+ * @param options - Optional configuration options for splitting the string.
+ * @param options.isMarkdown - If true, it's markdown format string.
+ * @returns A two-dimensional array where each sub-array represents a paragraph.
+ */
+declare function splitParagraph(value: string, options?: SplitSentenceOptions): string[][];
 
 /**
  * Truncates(Round) a number to a specified number of decimal places.
@@ -1125,13 +1178,28 @@ declare const base32768: typeof _base32768;
 
 declare function xxhash32(value: string | object, radix?: number): string;
 declare function xxhash64(value: string | object, radix?: number): string;
-declare enum XXHashAlgorithm {
+declare enum HashAlgorithm {
+    md5 = 1,
+    sha1 = 2,
+    ripemd = 3,
+    sha256 = 8,
+    sha384 = 9,
+    sha512 = 10,
+    sha224 = 11,
+    xxhash = 111,
     xxhash64 = 111,
-    xxhash32 = 112
+    xxhash32 = 112,
+    xxhash128 = 113
 }
 type HashValue = string | ArrayBuffer | Buffer;
-declare function xxhash(value: HashValue, hashAlgo?: XXHashAlgorithm, seed?: number): Uint8Array;
-declare function xxhashAsStr(value: string | Uint8Array, hashAlgo?: XXHashAlgorithm, seed?: number): string;
+declare function xxhash(value: HashValue, hashAlgo?: HashAlgorithm, seed?: number): Uint8Array;
+declare function xxhashAsStr(value: string | Uint8Array, hashAlgo?: HashAlgorithm, seed?: number): string;
+interface HashAlgoParams {
+    hashAlgo?: HashAlgorithm;
+    seed?: number;
+    outputType?: 'hex' | 'binary' | 'string';
+}
+declare function hashStream(stream: ReadableStream, { hashAlgo, seed, outputType }?: HashAlgoParams): Promise<string | Uint8Array>;
 
 /**
  * Regular expression pattern for reserved characters in a filename.
@@ -1257,7 +1325,8 @@ declare function getAllEnumKeys<T extends object>(enumType: T): Array<keyof type
  * const json = parseJsJson(jsonString);
  * console.log(json); // { name: 'John' }
  */
-declare function parseJsJson(input: string, scope?: Record<string, any>): any;
+declare function parseJsJson(input: string, scope?: Record<string, any>): Promise<any>;
+declare function parseJsJsonSimpleSync(input: string, scope?: Record<string, any>): any;
 declare function filterValidFnScope(scope?: Record<string, any>): Record<string, any> | undefined;
 
 /**
@@ -1314,6 +1383,7 @@ declare function loadTextFromPaths(filename: string, searchPaths?: string[], ext
     filepath?: string;
     signal?: AbortSignal;
 } | BufferEncoding, exclude?: string[] | string): string;
+declare function decodeCharset(result: Buffer, encoding?: BufferEncoding): string;
 /**
  * Recursively reads all filenames in the given directory or directories.
  * Optionally filters the results using a file matching callback.
@@ -1330,7 +1400,7 @@ declare function loadTextFromPaths(filename: string, searchPaths?: string[], ext
 * ```
 */
 declare function readFilenamesRecursiveSync(dir: string | string[], options?: {
-    isFileMatched?: (filepath: string) => boolean;
+    isFileMatched?: (filepath: string, file: fs.Dirent | fs.Stats) => boolean;
     signal?: AbortSignal;
     level?: number;
 }): string[];
@@ -1347,6 +1417,19 @@ declare function readFilenamesRecursiveSync(dir: string | string[], options?: {
 * ```
 */
 declare function getRealFilepath(filepath: string): string;
+declare function hashFile(filepath: string, options?: HashAlgoParams): Promise<string | Uint8Array>;
+interface IFileMetaInfo {
+    name: string;
+    mtime: Date;
+    ctime: Date;
+    size: number;
+    hash: string;
+    mimeType: string;
+    id: string;
+}
+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): any;
@@ -1501,10 +1584,14 @@ interface AIChoiceConfig {
 }
 interface ParseObjectArgumentOptions {
     delimiter?: string;
+    assigner?: string;
     argProcessor?: ArgProcessor;
     returnArrayOnly?: boolean;
     templateFormat?: string;
     templateData?: Record<string, any>;
+    ignoreIndexNamed?: boolean;
+    preserveUnresolvedName?: boolean;
+    skipExpression?: boolean;
 }
 /**
  * Asynchronously parses a string of object arguments into an actual object.
@@ -1573,6 +1660,45 @@ declare function parseCommand(commandStr: string, scope?: Record<string, any>, o
     command: string;
     args?: Record<string, any>;
 }>;
+interface ReplacePlacehoderOptions {
+    startChar?: string | string[];
+    endChar?: string | string[];
+    placeholder?: string;
+    placehoders?: string[];
+}
+/**
+ * Replaces substrings in the given content with placeholders.
+ *
+ * @param content - The string content to process.
+ * @param options - Optional configuration object with the following properties:
+ *   - `startChar` - The starting character(s) of the substrings to replace. Can be a single character or an array of characters. Defaults to `["\"", "'"]`.
+ *   - `endChar` - The ending character(s) of the substrings to replace. Can be a single character or an array of characters. Defaults to the value of `startChar`.
+ *   - `placeholder` - The prefix for the placeholder names. Defaults to `defaultPlaceholderName`.
+ *   - `placehoders` - An array of placeholders to use instead of generating new one.
+ * @returns An array containing:
+ *   - `content` - The modified content with placeholders.
+ *   - `placehoders` - An array of the original substrings that were replaced.
+ * @throws {Error} If the lengths of `startChar` and `endChar` are not the same.
+ */
+declare function replaceWithPlaceholder(content: string, options?: ReplacePlacehoderOptions): [string, string[]];
+/**
+ * Restores the original substrings from placeholders in the given content.
+ *
+ * @param content - The string content containing placeholders to be restored.
+ * @param placehoders - An array of the original substrings that were replaced by placeholders.
+ * @param options - Optional configuration object with the following properties:
+ *   - `placeholder` - The prefix for the placeholder names. Defaults to `__PlacEhoLdeR_`.
+ * @returns The modified content with the original substrings restored.
+ *
+ * @example
+ * ```typescript
+ * const contentWithPlaceholders = "Hello __PlacEhoLdeR_0, welcome to __PlacEhoLdeR_1!";
+ * const originalSubstrings = ["World", "the site"];
+ * const restoredContent = restoreFromPlacehoders(contentWithPlaceholders, originalSubstrings);
+ * console.log(restoredContent); // Output: "Hello World, welcome to the site!"
+ * ```
+ */
+declare function restoreFromPlacehoders(content: string, placehoders: string[], options?: ReplacePlacehoderOptions): string;
 
 declare function memoize<F extends (...args: any[]) => any>(fn: any, options?: Options<F>): F & _memoize.Memoized<F>;
 
@@ -1622,4 +1748,279 @@ declare function hasDirectoryIn(dir: string, dirs?: string[]): boolean | undefin
 
 declare function isRegExp(value: any): boolean;
 
-export { AIArgProcessor, type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatToolMessageParam, type AIChatUserMessageParam, type AIChoiceConfig, type AIMessageType, AIMessageTypes, AIModelNameRules, type AIResult, AIStream, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, AsyncFeatures, type AsyncTaskId, CancelableAbility, type CancelableAbilityOptions, ChoiceArgProcessor, DefaultAsyncSemaphoreCapacity, type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, EventBusName, type EventErrorListenerFn, type EventListenerFn, EventName, FStringPromptTemplate, type FStringPromptTemplateNode, FewShotPromptTemplate, type FewShotPromptTemplateOptions, FilenameReservedRegex, GolangPromptTemplate, builtins as HFBuiltins, EnvironmentEx as HFEnvironment, Interpreter as HFInterpreter, Template as HFTemplate, HfPromptTemplate, IntSet, type JsonFilter, type ParseObjectArgumentOptions, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, RateLimit, ReadableStreamError, ResponseRStreamErrCode, type SanitizeFilenameOptions, Semaphore, type StreamCallbacksAndOptions, TaskAbortController, type TaskAbortControllers, type TaskPromise, TemplateArgProcessor, ToolFunc, WindowsReservedNameRegex, XXHashAlgorithm, backendEventable, base32768, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, dateToText, defaultTemplateFormat, expandEnv, expandObjEnv, extNameLevel, fileIsExists, filenameReservedRegex, filterValidFnScope, getAllEnumKeys, getConfigFileNames, getConfigs, getKeysPath, getMultiLevelExtname, getPackageDir, getRealFilepath, getResponseErrorReadableStream, hasDirectoryIn, parse as hfParse, tokenize as hfTokenize, interpolateEnv, interpolateFString, interpolateGolangTemplate, isModelNameMatched, isRegExp, isSubdirectory, isValidFilename, isValidFilepath, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadFileFromPaths, loadTextFromPaths, makeToolFuncCancelable, matchUrlProtocol, memoize, messagesToText, paramsSizeToScaleStr, parseCommand, parseFString, parseJsJson, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, parseYaml, quoteStr, reControlCharsRegex, readFilenamesRecursiveSync, readableFromAsyncIterable, registerYamlTag, sanitizeFilename, sanitizeFilepath, saveConfigFile, scaleStrToParamsSize, simplifyObjectArguments, sortedValues, splitSentence, stringifyYaml, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };
+declare function stripConsoleColor(str: any): any;
+
+declare const LLM_TOKENIZER_NAMES: {
+    'deepseek-ai/DeepSeek-V2-Lite-Chat': string;
+    'Qwen/Qwen2.5-0.5B': string;
+    'Xenova/gpt-4': string;
+    'Xenova/text-davinci-003': string;
+    'Xenova/gpt-3': string;
+    'Xenova/grok-1-tokenizer': string;
+    'Xenova/claude-tokenizer': string;
+    'Xenova/mistral-tokenizer-v3': string;
+    'Xenova/mistral-tokenizer-v1': string;
+    'Xenova/gemma-tokenizer': string;
+    'Xenova/gemma2-tokenizer': string;
+    'Xenova/llama3-tokenizer-new': string;
+    'unsloth/Llama-3.2-1B-Instruct': string;
+    'Xenova/llama-tokenizer': string;
+    'Xenova/c4ai-command-r-v01-tokenizer': string;
+    'Xenova/t5-small': string;
+    'Xenova/bert-base-cased': string;
+};
+declare const LLM_TOKENIZER_NAMES_MAP: any;
+declare function getLLMTokenizer(modelId: string): Promise<PreTrainedTokenizer>;
+declare function encodeLLMTokens(text: string, modelId?: string): Promise<number[]>;
+declare function countLLMTokens(text: string, modelId?: string): Promise<number>;
+
+/**
+ * Formats the input text by replacing delimiters with spaces and optionally capitalizing the first letter of each word.
+ *
+ * @param input - The input string to be formatted.
+ * @param options - Optional configuration for formatting.
+ * @param options.capitalize - Whether to capitalize the first letter of each word. Defaults to `true`.
+ * @param options.delimiter - The delimiter used to split the words. Defaults to `/[_-]/g`.
+ *
+ * @example
+ * // Returns "Hello World"
+ * formatTextWithSpace("hello_world");
+ *
+ * @example
+ * // Returns "This Is A Test"
+ * formatTextWithSpace("this-is-a-test", { delimiter: /-/g });
+ *
+ * @example
+ * // Returns "hello world"
+ * formatTextWithSpace("hello_world", { capitalize: false });
+ *
+ * @example
+ * // Returns "Hello World This Is A Test"
+ * formatTextWithSpace("hello-world_this_is_a_test");
+ */
+declare function formatTextWithSpace(input: string, options?: {
+    capitalize?: boolean;
+    delimiter?: string | RegExp;
+}): string;
+
+interface ITruncateToTokenLimitOptions {
+    bySentence?: boolean;
+    size?: number;
+    modelId?: string;
+    sentences?: string[];
+    best?: boolean;
+    completeSentence?: boolean;
+    corrected?: boolean;
+    truncLastSection?: boolean;
+    countLLMTokens?: (text: string, modelId?: string) => Promise<number>;
+}
+/**
+ * Truncates the given content to fit within a specified token limit by removing sentences from the end.
+ * This function is suitable for text content with multiple sentences.
+ * @param content - The original text content to be processed.
+ * @param options - Optional configuration including model ID and size limit.
+ * @returns The truncated text content.
+ *
+ * @example
+ * ```typescript
+ * const text = "This is an example text that will be truncated to fit within the token limit. It contains multiple sentences. Each sentence will be removed until the content fits within the specified token limit. This is the fourth sentence. This is the fifth sentence.";
+ * const truncatedText = await truncateToTokenLimit(text, { modelId: "exampleModel", size: 50 });
+ * console.log(truncatedText); // Output may be the truncated text
+ * ```
+ *
+ * @warning This function is designed for text content with multiple sentences.
+ */
+declare function truncateToTokenLimit(content: string, options?: ITruncateToTokenLimitOptions): Promise<string>;
+declare function truncateToTokenLimitEx(sentences: string[], options?: ITruncateToTokenLimitOptions): Promise<string[]>;
+declare function truncateByToken(content: string, options?: ITruncateToTokenLimitOptions): Promise<void>;
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+
+@example
+```
+import type {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+type RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType = keyof ObjectType,
+> = {
+	// For each `Key` in `KeysType` make a mapped type:
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
+	// 2. Make all other keys in `KeysType` optional
+	Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] &
+// 3. Add the remaining keys not in `KeysType`
+Except<ObjectType, KeysType>;
+
+interface IReadTextFileChunksOptions extends ITruncateToTokenLimitOptions {
+    size?: number;
+    modelId?: string;
+    metaInfo?: RequireAtLeastOne<Partial<IFileMetaInfo>, 'size'>;
+}
+/**
+ * Reads a text file and yields chunks of text that are within a specified token limit.
+ * This function supports both small files that can be read entirely into memory,
+ * and large files that require streaming.
+ *
+ * Note: The specified `size` must not be less than the token count of the longest sentence.
+ * If the `size` is less than the token count of the longest sentence, some sentences may not
+ * fit completely into a single chunk.
+ * Without completeSentence and corrected Only!
+ *
+ * @param filePath - The path to the text file to be read.
+ * @param options - optional Options for reading the file.
+ * @param options.size - optional The maximum token size per chunk. Default is 1984.
+ * @param options.modelId - optional The ID of the model used for token counting.
+ * @param options.metaInfo - optional Metadata about the file, including its size.
+ *
+ * @example
+ * ```typescript
+ * const filePath = 'path/to/file.txt';
+ * const options = {
+ *   size: 2048,
+ *   modelId: 'gpt-3.5',
+ *   metaInfo: { size: 10240 }
+ * };
+ *
+ * for await (const chunk of readTextFileChunks(filePath, options)) {
+ *   console.log('Chunk:', chunk);
+ * }
+ * ```
+ */
+declare function readTextFileChunks(filePath: string, options?: IReadTextFileChunksOptions): AsyncIterable<string>;
+declare function readTextFileChunksEx(filePath: string, options?: IReadTextFileChunksOptions): AsyncIterable<string[]>;
+declare function splitChunks(content: string, options?: IReadTextFileChunksOptions): Promise<string[][]>;
+
+declare class YamlTypeBaseObject {
+    [name: string]: any;
+    constructor(options?: any);
+}
+declare function createYamlObjectTag(tag: string, BaseObject: typeof YamlTypeBaseObject): any;
+
+export { AIArgProcessor, type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatToolMessageParam, type AIChatUserMessageParam, type AIChoiceConfig, type AIMessageType, AIMessageTypes, AIModelNameRules, type AIResult, AIStream, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, AsyncFeatures, type AsyncTaskId, CancelableAbility, type CancelableAbilityOptions, ChoiceArgProcessor, DefaultAsyncSemaphoreCapacity, type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, EventBusName, type EventErrorListenerFn, type EventListenerFn, EventName, FStringPromptTemplate, type FStringPromptTemplateNode, FewShotPromptTemplate, type FewShotPromptTemplateOptions, FilenameReservedRegex, GolangPromptTemplate, builtins as HFBuiltins, EnvironmentEx as HFEnvironment, Interpreter as HFInterpreter, Template as HFTemplate, type HashAlgoParams, HashAlgorithm, HfPromptTemplate, type IFileMetaInfo, type IReadTextFileChunksOptions, type ITruncateToTokenLimitOptions, IntSet, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, type ParseObjectArgumentOptions, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, PromptTemplate, type PromptTemplateOptions, type PromptTemplateType, PromptTemplateTypes, type PromptType, PromptTypes, RStreamErrCode, RateLimit, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, type SanitizeFilenameOptions, type SectionStringOptions, Semaphore, type SplitSentenceOptions, type StreamCallbacksAndOptions, TaskAbortController, type TaskAbortControllers, type TaskPromise, TemplateArgProcessor, ToolFunc, WindowsReservedNameRegex, YamlTypeBaseObject, backendEventable, base32768, completeSentences, concatText, countLLMTokens, countRegexMatches, createCallbacksTransformer, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createHfValueFunc, createYamlObjectTag, dateToText, decodeCharset, defaultTemplateFormat, detectCharset, encodeLLMTokens, expandEnv, expandObjEnv, extNameLevel, fileIsExists, filenameReservedRegex, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, getAllEnumKeys, getConfigFileNames, getConfigs, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getMultiLevelExtname, getPackageDir, getRealFilepath, getResponseErrorReadableStream, hasDirectoryIn, hashFile, hashStream, parse as hfParse, tokenize as hfTokenize, interpolateEnv, interpolateFString, interpolateGolangTemplate, isLangUsingSpaces, isListItemString, isModelNameMatched, isPunctuationChar, isRegExp, isSectionString, isSentenceEnding, isSepLineString, isSubdirectory, isTitleString, isValidFilename, isValidFilepath, isWebStream, jsonFilterToWhere, jsonToMarkdownStr, loadFileFromPaths, loadTextFromPaths, makeToolFuncCancelable, matchUrlProtocol, memoize, messagesToText, paramsSizeToScaleStr, parseCommand, parseFString, parseJsJson, parseJsJsonSimpleSync, parseObjectArgInfo, parseObjectArgumentInfos, parseObjectArguments, parseObjectArgumentsAsArgInfos, parseYaml, quoteStr, reControlCharsRegex, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, registerYamlTag, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, sanitizeFilename, sanitizeFilepath, saveConfigFile, scaleStrToParamsSize, simplifyObjectArguments, sortedValues, splitChunks, splitParagraph, splitSentence, stringifyYaml, stripConsoleColor, textToDate, toDateTime, trimStartOfStreamHelper, truncTo, truncateByToken, truncateToTokenLimit, truncateToTokenLimitEx, uuid, wait, xxhash, xxhash32, xxhash64, xxhashAsStr };