@isdk/ai-tool 0.8.2 → 0.9.0

package/dist/index.d.ts

@@ -1,31 +1,46 @@
-import * as custom_ability from 'custom-ability';
+import { AsyncTaskId } from '@isdk/tool-func';
+export * from '@isdk/tool-func';
+export * from '@isdk/tool-rpc';
+export * from '@isdk/tool-event';
 export { createAbilityInjector } from 'custom-ability';
 export { toRegExp } from 'util-ex';
-import { A as AsyncTaskId, a as AIModelNameRules, I as IPubSubServerTransport, P as PubSubServerSession, b as PubSubClientId, 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-BLW3R7VS.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, ag as ClientEventPrefix, a1 as ClientFuncItem, a2 as ClientToolFuncSchema, a0 as ClientTools, D as DefaultAsyncSemaphoreCapacity, ae as EventClient, ad as EventClientFuncParams, ai as EventServer, ah as EventServerFuncParams, a7 as EventToolFunc, U as FuncItem, Z as FuncMetaSymbol, M as FuncParam, L as FuncParamType, N as FuncParams, av as IClientToolTransport, g as PASSING_SCORE, aw as PubSubCtx, t as RateLimit, k as RemoteFuncItem, R as RemoteToolFuncSchema, aq as ResClientFuncParams, ar as ResClientTools, as as ResServerFuncParams, at as ResServerTools, au as RpcMethodHandler, ak as RpcMethodsClientFuncParams, al as RpcMethodsClientTool, am as RpcMethodsClientToolSchema, an as RpcMethodsServerFuncParams, ao as RpcMethodsServerTool, ap as RpcMethodsServerToolSchema, 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, aj as eventServer, $ as funcGetMeta, _ as funcWithMeta, ac as lrucache, K as makeToolFuncCancelable, a6 as registerCoreTools } from './index-BLW3R7VS.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';
-export { nanoid } from 'nanoid';
-import { v1, v4, v5, v6, v7 } from 'uuid';
-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, v6 as uuidv6, v7 as uuidv7 } from 'uuid';
-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 { sleep } from '@isdk/util';
+export { BinarySemaphore, BinarySemaphoreAcquireOptions, BinarySemaphoreOptions, BinarySemaphoreReleaseOptions, ConfigFile, DefaultAsyncSemaphoreCapacity, FilenameReservedRegex, IntSet, RateLimit, SanitizeFilenameOptions, Semaphore, SemaphoreIsReadyFuncType, SemaphoreOptions, SemaphoreTaskItem, SignalGate, WindowsReservedNameRegex, extNameLevel, extractCodeBlock, findPort, getMultiLevelExtname, isValidFilename, isValidFilepath, parseYaml, registerYamlTag, sanitizeFilename, sanitizeFilepath, sleep, stringifyYaml, yieldExec } from '@isdk/util';
+import { HashAlgoParams, HashAlgorithm } from '@isdk/hash';
+export { HashAlgoParams, HashAlgorithm, UUIDVersions, base32768, hash, hashObject, hashStream, uuid, xxhash, xxhash32, xxhash64, xxhashAsStr } from '@isdk/hash';
 import * as fs from 'fs';
 import _memoize, { Options } from 'memoizee';
-export { f as findPort } from './find-port-qS1CZ9c-.js';
 import { PreTrainedTokenizer } from '@huggingface/transformers';
 export { canonicalize } from 'json-canonicalize';
+export { SecondaryCache, _lrucache, createLRUCache, lrucache, registerCoreTools } from './funcs.js';
 export { mimeType } from 'mime-type/with-db';
 export { add as addDate, formatISO, parse as parseDateFormat, parseISO, toDate } from 'date-fns';
 export { LRUCache } from 'secondary-cache';
-import 'property-manager';
+
+/**
+ * A constant representing a passing score, likely used for similarity or relevance thresholds.
+ */
+declare const PASSING_SCORE = 0.618;
+/**
+ * Defines the signature for a function that processes an AI model's name,
+ * typically for matching or validation purposes.
+ * @param name - The model name string.
+ * @returns A string, a RegExp execution array, or undefined if no match is found.
+ */
+type AIModelNameRuleFn = (name: string) => string | RegExpExecArray | undefined;
+/**
+ * Defines a single rule for matching an AI model name. It can be a simple string,
+ * a regular expression, or a custom function.
+ */
+type AIModelNameRule = string | RegExp | AIModelNameRuleFn;
+/**
+ * Represents a collection of one or more AI model name matching rules.
+ */
+type AIModelNameRules = AIModelNameRule | AIModelNameRule[];
 
 declare const AITextGenerationFinishReasons: readonly ["stop", "length", "content_filter", "tool_calls", "function_call", "abort", "error", "other", null];
 type AITextGenerationFinishReason = typeof AITextGenerationFinishReasons[number];
@@ -48,16 +63,25 @@ 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 AIChatRoles: readonly ["user", "assistant", "system", "tool"];
+type AIChatRole = (typeof AIChatRoles[number]) | (string & {});
 declare const StrangeHumanName = "\u964C\u751F\u4EBA";
-type AIChatRole = (typeof AIChatRoles[number]) & string;
+interface AIChatToolDefinition {
+    name?: string;
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: any;
+    };
+}
 type AIChatMessageParam = AIChatMessageParamBase | AIChatSystemMessageParam | AIChatUserMessageParam | AIChatAssistantMessageParam | AIChatToolMessageParam;
 interface AIChatMessageParamBase {
-    role: string;
+    role: AIChatRole;
     toRole?: string | string[] | Record<string, Partial<AIChatMessageParam>>;
     replies?: Record<string, Partial<AIChatMessageParam>>;
     private?: boolean;
-    tools?: Record<string, string>;
+    tools?: AIChatToolDefinition[];
     thinking?: string;
     [name: string]: any;
 }
@@ -75,14 +99,18 @@ interface AIChatUserMessageParam extends AIChatMessageParamBase {
     from?: 'speech' | string;
     templateFormat?: string;
 }
-type AIChatContentPart = AIChatContentPartText | AIChatContentPartImage;
-interface AIChatContentPartImage {
+type AIChatContentPart = AIChatContentPartBase | AIChatContentPartText | AIChatContentPartImage;
+interface AIChatContentPartBase {
+    type: 'text' | 'image_url' | string;
+    [name: string]: any;
+}
+interface AIChatContentPartImage extends AIChatContentPartBase {
     type: 'image_url';
     image_url: {
         url: string;
     };
 }
-interface AIChatContentPartText {
+interface AIChatContentPartText extends AIChatContentPartBase {
     type: 'text';
     text: string;
 }
@@ -96,16 +124,17 @@ interface AIChatAssistantMessageParam extends AIChatMessageParamBase {
 }
 interface AIChatMessageToolCall {
     type: 'function';
-    id: string;
+    id?: string;
     function: {
-        arguments: string;
         name: string;
+        arguments?: string | any;
+        description?: string;
     };
 }
 interface AIChatToolMessageParam extends AIChatMessageParamBase {
     role: 'tool';
     content: string;
-    tool_call_id: string;
+    tool_call_id?: string;
     templateFormat?: string;
 }
 interface AIChatToolParam {
@@ -135,6 +164,150 @@ interface AIChatToolTypeObject {
     name: string;
 }
 declare function messagesToText(messages: AIChatMessageParamBase[]): string;
+/**
+ * Capabilities detected for a chat template (ChatML-like) with respect to
+ * OpenAI-compatible function/tool calling in llama.cpp-style pipelines.
+ *
+ * Each flag describes what the template can (or must) do when rendering messages/tools,
+ * so your caller can adapt message shaping, tool-calling strategy, and fallbacks.
+ *
+ * Detection is typically performed by rendering small “probe” conversations against
+ * the template and inspecting the resulting text.
+ *
+ */
+type AIChatTemplateCaps = {
+    /**
+     * Whether the template requires OpenAI-style "typed content" parts instead of a plain string.
+     *
+     * @remarks
+     * - true: A message like `{ content: "..." }` is ignored, while
+     *   `{ content: [{ type: "text", text: "..." }] }` renders correctly.
+     * - false: Both plain strings and typed parts render.
+     *
+     * @impact
+     * - If true, wrap all string content as text parts before rendering:
+     *   `{ content: [{ type: "text", text }] }`.
+     *
+     * @example
+     * if (caps.requiresTypedContent && typeof msg.content === "string") {
+     *   msg.content = [{ type: "text", text: msg.content }];
+     * }
+     */
+    requiresTypedContent: boolean;
+    /**
+     * Whether the template actually includes role=system messages in the rendered prompt.
+     *
+     * @remarks
+     * - true: You can pass `messages: [{ role: "system", ... }, ...]` and expect
+     *   the system text to appear at the top of the prompt.
+     * - false: The template ignores system; move your “system rules” into the first user/assistant turn or edit the template.
+     *
+     * @impact
+     * - If false, critical behavior instructions should be injected via the template itself
+     *   or merged into the first turn.
+     */
+    supportsSystemRole: boolean;
+    /**
+     * Whether the template consumes the top-level `tools` array (function catalog) and renders it into the prompt.
+     *
+     * @remarks
+     * - true: The model sees a readable list of available functions (names, descriptions, schemas).
+     * - false: The template doesn’t show the catalog; tool-calling can still work, but the model
+     *   may be less aware of function options unless you add guidance text.
+     *
+     * @impact
+     * - If false, consider adding a short “How to call tools” section or a generated example to the template.
+     */
+    supportsTools: boolean;
+    /**
+     * Whether the template properly renders an assistant message that contains `tool_calls` (OpenAI format).
+     *
+     * @remarks
+     * - true: An assistant message with `tool_calls: [{ type: "function", function: { name, arguments }}, ...]`
+     *   gets serialized in the template’s tool-call section.
+     * - false: The template does not serialize tool calls correctly; switch template/handler,
+     *   fall back to a Generic handler, or use the “pure JSON intent” two-turn strategy.
+     *
+     * @impact
+     * - If false, do not rely on OpenAI `tool_calls` in a single assistant turn.
+     */
+    supportsToolCalls: boolean;
+    /**
+     * Whether the template expects `function.arguments` to be a JSON object (not a JSON-string literal).
+     *
+     * @remarks
+     * - true: Pass arguments as an object: `{ arguments: { ... } }`. Supplying a stringified JSON may double-escape or break parsing.
+     * - false: Both object and string are accepted (object is still recommended for stricter grammar alignment).
+     *
+     * @impact
+     * - Honor this when constructing assistant messages that contain `tool_calls`.
+     *
+     * @example
+     * const args = caps.requiresObjectArguments ? { city: "SF" } : JSON.stringify({ city: "SF" });
+     */
+    requiresObjectArguments: boolean;
+    /**
+     * Whether a single assistant message can contain multiple tool calls and be rendered correctly.
+     *
+     * @remarks
+     * - true: The template can serialize an array of calls in one assistant turn.
+     * - Note this only opens the possibility; the runtime must also allow it
+     *   (e.g., request `parallel_tool_calls: true` and use a grammar with an array top rule),
+     *   and the model must actually choose to emit multiple calls.
+     * - false: Even if the API flag is set, only 0/1 call will practically work per turn.
+     *
+     * @impact
+     * - Enable/disable “same-turn multi-call” orchestration accordingly.
+     */
+    supportsParallelToolCalls: boolean;
+    /**
+     * Whether the template renders role=tool messages (tool/function execution results) back into the prompt context.
+     *
+     * @remarks
+     * - true: The model can see tool outputs (often near the next assistant generation).
+     * - false: Tool results aren’t visible; inject them as user/system text instead, or update the template to render tool messages.
+     *
+     * @impact
+     * - Critical for the standard call→execute→return→answer loop to converge.
+     */
+    supportsToolResponses: boolean;
+    /**
+     * Whether the template surfaces `tool_call_id` when rendering role=tool results, enabling strict mapping back to the call.
+     *
+     * @remarks
+     * - true: Each tool output can be visibly tied to its originating call (important for multi-call turns).
+     * - false: The mapping is implicit; include the call id in the text or restrict to single calls per turn.
+     *
+     * @impact
+     * - Strongly recommended when parallel/multiple tool calls are possible.
+     */
+    supportsToolCallId: boolean;
+    /**
+     * Whether the template forbids `assistant.content` being `null` (requires an empty string instead).
+     *
+     * @remarks
+     * - true: Use `content: ""` as a placeholder when the assistant turn only carries `tool_calls`.
+     * - false: `null` or `""` both work.
+     *
+     * @impact
+     * - Prevents template branches from swallowing messages when content is `null`.
+     */
+    requiresNonNullContent: boolean;
+    /**
+     * A generated “how to call a tool” example snippet, inferred only when the template doesn’t render the tools catalog.
+     *
+     * @remarks
+     * - Present when {@link ChatTemplateCaps.supportsTools} is false and the probe could
+     *   derive a stable example by diffing “prefix only” vs “prefix + a fake tool call”.
+     * - Useful to inject into the template/system text to teach the expected call format.
+     *
+     * @example
+     * if (!caps.supportsTools && caps.toolCallExample) {
+     *   system += "\n\nTool call example:\n" + caps.toolCallExample;
+     * }
+     */
+    toolCallExample?: string;
+};
 
 type PromptExamples<T = any> = Iterable<PromiseLike<T> | T> | AsyncIterable<T>;
 interface PromptExampleSelectorOptions {
@@ -253,7 +426,7 @@ declare class FewShotPromptTemplate<T = any> extends StringTemplate {
     static from<T = any>(options: FewShotPromptTemplateOptions<T>): FewShotPromptTemplate<T>;
     constructor(options: FewShotPromptTemplateOptions<T>);
     _initialize(options?: FewShotPromptTemplateOptions<T>): void;
-    _format(data: Record<string, any>): Promise<string>;
+    _format(data: Record<string, any>): Promise<any>;
     toJSON(options?: this): FewShotPromptTemplateOptions<T>;
 }
 
@@ -338,18 +511,6 @@ declare function splitParagraph(value: string, options?: SplitSentenceOptions):
  */
 declare function truncTo(n: number, dec?: number, up?: number): number;
 
-/**
- * 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
@@ -358,154 +519,6 @@ declare function sleep(ms: number): Promise<void>;
  * 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";
-type EventListenerFn = (this: Event, name: string, ...args: any) => any;
-type EventErrorListenerFn = (this: Event, err: Error, name: string, ...args: any) => any;
-declare function getEventableClass(Backend: any, options?: {
-    eventBusName?: string;
-}): {
-    new (): {
-        name: string;
-        _events: any;
-        readonly emitter: any;
-        on(eventName: string, listener: EventListenerFn): EventEmitter | void;
-        once(eventName: string, listener: EventListenerFn): EventEmitter | void;
-        off(type: string, listener: EventListenerFn): EventEmitter;
-        emit(eventName: string, ...args: any[]): any;
-        emitError(err: any, ...args: any[]): any;
-        emitAsync(eventName: string, ...args: any[]): Promise<any>;
-    };
-    _emitter: any;
-    readonly emitter: 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 SSEClient = {
-    /** 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.
-     */
-    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: Map<string, SSEClient>;
-    messages: Record<string, any>[];
-    nextID: number;
-    options: Record<string, any>;
-    pingTimer?: NodeJS.Timeout;
-    /**
-     * Gets the active status of the channel.
-     * @returns True if the channel is active, false otherwise.
-     */
-    get active(): boolean;
-    set active(v: boolean);
-    /**
-     * Creates a new SSE channel.
-     * @param options - The options for the SSE channel.
-     * @param options.pingInterval - Interval in milliseconds to send ping messages (default: 3000).
-     * @param options.maxStreamDuration - Maximum duration of a client connection in milliseconds (default: 30000).
-     * @param options.clientRetryInterval - Interval in milliseconds for clients to retry connection (default: 1000).
-     * @param options.startId - Starting ID for messages (default: 1).
-     * @param options.historySize - Maximum number of messages to keep in history (default: 100).
-     * @param options.rewind - Number of historical messages to send to new clients (default: 0).
-     * @param options.cors - Whether to enable CORS headers (default: false).
-     */
-    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;
-    /**
-     * Adds event subscriptions to an active client.
-     * @param clientId The ID of the client to modify.
-     * @param events An array of event names or patterns to add.
-     * @returns `true` if the client was found and updated, otherwise `false`.
-     */
-    subscribe(clientId: string, events: Events): boolean;
-    /**
-     * Removes event subscriptions from an active client.
-     * @param clientId The ID of the client to modify.
-     * @param events An array of event names or patterns to remove.
-     * @returns `true` if the client was found and updated, otherwise `false`.
-     */
-    unsubscribe(clientId: string, events: Events): boolean;
-    /**
-     * Finds a client instance by its unique ID.
-     * @param clientId The unique ID of the client.
-     * @returns The matching SSEClient, or undefined if not found.
-     */
-    getClient(clientId: string): SSEClient | undefined;
-    /**
-     * Establishes a new SSE connection with a client and adds it to the channel.
-     *
-     * @param req The incoming HTTP request from the client.
-     * @param res The server response object used to send events to the client.
-     * @param events An array of event names or patterns that the client wants to subscribe to.
-     * @param clientId An optional unique identifier for the client. If not provided, one will be generated based on the client's IP and port.
-     * @returns The newly created client object representing the connected client.
-     * @throws An error if the channel is closed or if a client ID cannot be determined.
-     */
-    connect(req: IncomingMessage, res: ServerResponse, events?: Events, clientId?: string): SSEClient;
-    /**
-     * Disconnects a client from the SSE channel and cleans up resources.
-     * @param c - The client to disconnect.
-     */
-    disconnect(c: SSEClient): void;
-    /**
-     * Disconnects all clients from the SSE channel.
-     */
-    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>;
 
@@ -590,94 +603,6 @@ declare function AIStream<T = any, TOptions = any>(response: Response, customPar
  */
 declare function readableFromAsyncIterable<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
 
-/**
- * Configuration options and helper callback methods for stream lifecycle events.
- * @interface
- */
-interface StreamCallbacksAndOptions<I = any, O = any> {
-    /** `onStart`: Called once when the stream is initialized. */
-    onStart?: (controller: TransformStreamDefaultController) => Promise<void> | void;
-    /** `onToken`: Called for each tokenized message. */
-    onTransform?: (chunk: I, controller: TransformStreamDefaultController) => Promise<O | void> | O | void;
-    /** `onFinal`: Called once when the stream is closed with the final completion message. */
-    onFinal?: (controller: TransformStreamDefaultController) => Promise<void> | void;
-    onError?: (error: Error) => Promise<void> | void;
-}
-/**
- * Creates a transform stream that invokes optional callback functions.
- * The transform stream uses the provided callbacks to execute custom logic at different stages of the stream's lifecycle.
- * - `onStart`: Called once when the stream is initialized.
- * - `onTransform`: Called for each tokenized message.
- * - `onCompletion`: Called every time an AIStream completion message is received. This can occur multiple times when using e.g. OpenAI functions
- * - `onFinal`: Called once when the stream is closed with the final completion message.
- *
- * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
- *
- * @param [callbacks] - An object containing the callback functions.
- * @return A transform stream that encodes input messages as Uint8Array and allows the execution of custom logic through callbacks.
- *
- * @example
-* const callbacks = {
-*   onStart: async () => console.log('Stream started'),
-*   onTransform: async (chunk) => console.log('Token:',chunk),
-*   onFinal: async () => data.close()
-* };
-* const transformer = createCallbacksTransformer(callbacks);
-*/
-declare function createCallbacksTransformer<I = any, O = any>(cb: StreamCallbacksAndOptions<I, O> | undefined): TransformStream<I, O>;
-
-declare const uuids: {
-    1: typeof v1;
-    4: typeof v4;
-    5: typeof v5;
-    6: typeof v6;
-    7: typeof v7;
-};
-type UUIDVersions = keyof typeof uuids;
-/**
- * Generates a UUID (Universally Unique Identifier) based on the specified version and encoding options.
- *
- * @param encode - Whether to encode the generated UUID using Base32768 encoding. Defaults to `false`.
- *
- * @returns A string representing the generated UUID. If `encode` is `true`, the UUID will be encoded in Base32768 format.
- *
- * @example
- * // Generate an encoded UUID version 1 using Base32768
- * const encodedUuid1 = uuid(true);
- */
-declare function uuid(encode?: boolean): string;
-
-declare enum HashAlgorithm {
-    md5 = 1,
-    sha1 = 2,
-    ripemd = 3,
-    sha256 = 8,
-    sha384 = 9,
-    sha512 = 10,
-    sha224 = 11,
-    xxhash = 111,
-    xxhash64 = 111,
-    xxhash32 = 112,
-    xxhash128 = 113
-}
-
-declare function xxhash32(value: string | object, radix?: number): string;
-declare function xxhash64(value: string | object, radix?: number): string;
-type HashValue = string | ArrayBuffer | Buffer;
-declare function xxhash(value: HashValue, hashAlgo?: HashAlgorithm, seed?: number): Uint8Array;
-declare function xxhashAsStr(value: string | Uint8Array, hashAlgo?: HashAlgorithm, seed?: number): string;
-
-declare const base32768: typeof _base32768;
-
-interface HashAlgoParams {
-    hashAlgo?: HashAlgorithm;
-    seed?: number;
-    outputType?: 'hex' | 'binary' | 'string';
-}
-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.
  * @param modelName The name of the model to check.
@@ -912,205 +837,521 @@ declare function textToDate(date: string, format?: string): Date;
 declare function dateToText(date: Date, format?: string): string;
 
 /**
- * Represents a set of integers using a bit field.
- * Each bit in the bit field represents an integer starting from 0,
- * where the flag value 0 represents the 0th bit, 1 represents the 1st bit, and so on.
+ * Counts the number of matches for a given regular expression in a specified string.
+ * This function ensures that the regular expression is used globally by adding the 'g' flag,
+ * if it is not already present.
+ *
+ * @param content - The string to search within.
+ * @param regex - The regular expression to use for matching.
+ * @returns The total number of matches found.
+ */
+declare function countRegexMatches(content: string, regex: RegExp): number;
+
+/**
+ * Lexical analyzer for command arguments.
+ * Responsible for breaking down the raw input string into a sequence of basic tokens.
  */
-declare class IntSet {
-    private bitField;
-    static has(bitField: number, flag: number): boolean;
-    static add(bitField: number, flag: number): number;
-    static delete(bitField: number, flag: number): number;
-    constructor(bitField?: number);
+declare class CmdArgLexer {
+    input: string;
+    private pos;
+    private delimiter;
+    private assigner;
+    constructor(input: string, options?: CmdArgParserOptions);
     /**
-     * Adds an element to the set.
-     *
-     * @param flag - The flag value representing the bit position to set.
-     *              Note: the flag value 0 represents the 0th bit, and so on.
+     * Peeks at the next CmdArgToken without consuming it.
      */
-    add(flag: number): this;
+    peekToken(): CmdArgToken;
     /**
-     * Removes an element from the set.
-     *
-     * @param flag - The flag value representing the bit position to set. 0 represents the 0th bit
+     * Retrieves the next CmdArgToken and advances the position pointer.
      */
-    delete(flag: number): this;
+    nextToken(): CmdArgToken;
     /**
-     * Determines whether an element is in the set.
+     * Reads a quoted string with escape support.
+     */
+    private readString;
+    /**
+     * Reads a raw text segment.
+     */
+    private readRaw;
+    private skipWhitespace;
+    reset(): void;
+}
+
+/**
+ * Structured command argument CmdArgParser.
+ * Supports positional arguments, named arguments (k=v), nested structures,
+ * and Symbol-based extension protocols.
+ */
+declare class CmdArgParser {
+    private lexer;
+    private options;
+    constructor(lexer: CmdArgLexer, options?: CmdArgParserOptions);
+    /**
+     * Executes the parsing process.
      *
-     * @param flag - The flag value representing the bit position to set. 0 represents the 0th bit
-     * @returns true if the element is in the set; otherwise, false.
+     * Core logic priority:
+     * 1. Collect top-level arguments (respecting bracket nesting depth).
+     * 2. Identify explicit named arguments (k=v) or flag shorthands.
+     * 3. Pre-check if a positional argument fits identifier/path format for auto-mapping.
+     * 4. Invoke Evaluator to get the value and unpack any Symbol Protocols.
+     * 5. Distribute results to 'args' and 'namedArgs', maintaining index consistency.
+     */
+    parse(): Promise<CmdArgParseResult>;
+    /**
+     * Collects tokens until a top-level delimiter is encountered.
+     */
+    private collectUntilDelimiter;
+    /**
+     * Attempts to split a named key (k=v) or flag (!k=v) from the CmdArgToken sequence.
      */
-    has(flag: number): boolean;
+    private splitNamedArgument;
+    private isLeftBracket;
+    private isRightBracket;
     /**
-     * Clears all elements from the set.
+     * Consumes the current delimiter CmdArgToken.
      */
-    clear(): this;
-    valueOf(): number;
-    toString(): string;
-    toJSON(): number;
+    private consumeDelimiter;
 }
 
 /**
- * An asynchronous signal gate that blocks operations until a signal is emitted.
- * This class allows multiple awaiters to wait for a signal and resolves all pending promises with the emitted value.
- * The gate can be reset to reuse for subsequent signals.
+ * Symbol used to mark a result object returned by an ArgProcessor.
+ * The processor should return an object where this Symbol is the key.
  *
  * @example
+ * ```ts
+ * return {
+ *   [CMD_ARG_PROCESSOR_RESULT]: [parsedValue, 'suggestedName', { excludePositional: true }]
+ * };
+ * ```
+ */
+declare const CMD_ARG_PROCESSOR_RESULT: unique symbol;
+/**
+ * Internal Symbol used to mark values that have fallen back to their raw string
+ * representation due to a ReferenceError (undefined variable).
+ * This allows the CmdArgParser to distinguish between a deliberate string "undefined"
+ * and a failed variable lookup.
+ */
+declare const CMD_ARG_UNRESOLVED_SYMBOL: unique symbol;
+/**
+ * Symbol used to mark special parameters (Flags) in a wrapped object.
+ * Stored as a non-enumerable property on the wrapped value (e.g., Boolean, String).
  *
- * ```typescript
- * // Default type is void, can call signal() without parameters
- * const gate = new SignalGate();
- * gate.signal(); // No parameters required
- *
- * // Example with explicit type
- * const valueGate = new SignalGate<number>();
- * valueGate.signal(42); // Must provide a number value
+ * @example
+ * ```ts
+ * const CmdArgFlagValue = flags['debug'];
+ * const prefix = CmdArgFlagValue[CMD_ARG_FLAG_SYMBOL]; // returns '!'
  * ```
  */
-declare class SignalGate<T = void> {
-    protected _isSignaled: boolean;
-    protected _signalValue: T | undefined;
-    protected waitQueue: Array<{
-        resolve: (value: T) => void;
-        reject: (error: any) => void;
-    }>;
-    get signaled(): boolean;
+declare const CMD_ARG_FLAG_SYMBOL: unique symbol;
+/**
+ * Metadata attached to flag values.
+ */
+interface CmdArgFlagMetadata {
+    /** The prefix used to define this flag (e.g., '!', '#') */
+    [CMD_ARG_FLAG_SYMBOL]: string;
+}
+/**
+ * A flag value is a wrapped primitive (Boolean, String, Number) or object
+ * that carries its prefix metadata via CMD_ARG_FLAG_SYMBOL.
+ */
+type CmdArgFlagValue = (Boolean | String | Number | any) & CmdArgFlagMetadata;
+/**
+ * A map of flag names to their wrapped values.
+ */
+type CmdArgFlagsRecord = Record<string, CmdArgFlagValue>;
+/**
+ * CmdArgToken types for lexical analysis.
+ */
+declare enum CmdArgTokenType {
+    EOF = "EOF",
+    /** Argument delimiter (default: ',') */
+    COMMA = "COMMA",
+    /** Assignment operator (default: '=' or ':') */
+    ASSIGN = "ASSIGN",
+    /** Left parenthesis '(' */
+    L_PAREN = "L_PAREN",
+    /** Right parenthesis ')' */
+    R_PAREN = "R_PAREN",
+    /** Left square bracket '[' */
+    L_BRACKET = "L_BRACKET",
+    /** Right square bracket ']' */
+    R_BRACKET = "R_BRACKET",
+    /** Left curly brace '{' */
+    L_BRACE = "L_BRACE",
+    /** Right curly brace '}' */
+    R_BRACE = "R_BRACE",
+    /** Quoted string "..." or '...' or `...` */
+    STRING = "STRING",
+    /** Valid JS identifier (excluding reserved words like true/false) */
+    IDENTIFIER = "IDENTIFIER",
+    /** Raw text segment, used for expressions or unquoted strings */
+    RAW = "RAW"
+}
+/**
+ * Represents a lexical CmdArgToken with its type, value, and source position.
+ */
+interface CmdArgToken {
+    /** The type of the CmdArgToken */
+    type: CmdArgTokenType;
+    /** The literal string value of the CmdArgToken */
+    value: string;
+    /** Starting index in the input string */
+    start: number;
+    /** Ending index in the input string */
+    end: number;
+}
+/**
+ * Options for processors to control how the parsed value is distributed in the final result.
+ */
+interface CmdArgProcessorResultOptions {
     /**
-     * Emits the signal with an optional value, resolving all pending {@link wait} promises.
-     * Subsequent calls have no effect until {@link reset} is called.
-     *
-     * @param value The value to emit with the signal (only required if T is not void).
+     * If true, the argument will be excluded from the positional `args` array.
+     * Useful when a positional argument is intended to be treated as a named parameter only.
      */
-    signal(value?: T): void;
+    excludePositional?: boolean;
+}
+
+/**
+ * Symbol used to mark a result object returned by an ArgProcessor.
+...
+ */
+interface CmdArgContext {
+    /** True if the argument was explicitly assigned using an assigner (e.g., k=v) */
+    isNamed: boolean;
+    /** The raw input substring of this argument (after stripping the name and assigner if present) */
+    rawValue: string;
+    /** The explicitly specified name (k) in a `k=v` pair */
+    name?: string;
     /**
-     * Resets the gate to its initial state, allowing a new signal to be emitted.
+     * If the argument is positional and its raw text is a valid identifier,
+     * this holds that identifier name (used for auto-mapping).
      */
-    reset(): void;
+    identifierAsName?: string;
+    /** All lexical tokens belonging to this argument */
+    tokens: CmdArgToken[];
+    /** The 0-based index of this argument in the positional sequence */
+    index: number;
+    /** The evaluation scope containing variables and functions */
+    scope?: Record<string, any>;
+    /** The configuration options used by the CmdArgParser */
+    options: CmdArgParserOptions;
+    /** Reference to the CmdArgParser instance for recursive parsing */
+    CmdArgParser: CmdArgParser;
+}
+/**
+ * Type definition for an argument processor function.
+ * It can return a plain value (for standard evaluation) or a Protocol-compliant object.
+ */
+type ArgProcessor = (ctx: CmdArgContext) => any | Promise<any>;
+/**
+ * Detailed configuration for result simplification (convergence).
+ */
+interface CmdArgSimplifyOptions {
     /**
-     * Aborts all pending waits, rejecting their promises with an error.
-     * This does **not** reset the signal state (the gate remains signaled or unsignaled).
-     *
-     * @param reason The reason for aborting the waits.
+     * [Single Value Simplification]
+     * If there is exactly one positional argument and no named arguments, return the value directly.
+     * @example parse("123") -> 123 (instead of [123])
+     * @default true
+     */
+    singleValue?: boolean;
+    /**
+     * [Identical Pair Singularization]
+     * If there are exactly two entries (index 0 and a named key) and their values are identical,
+     * collapse them into a single value. This often happens when `idAsName` is enabled.
+     * @example parse("name=John") -> "John" (instead of {0: "John", name: "John"})
+     * @default true
      */
-    abort(reason?: any): void;
+    identicalPairSingular?: boolean;
     /**
-     * Returns a promise that resolves with the emitted signal value.
-     * If called after the signal has been emitted, resolves immediately with the stored value.
+     * [Pure Positional as Array]
+     * If there are multiple positional arguments and no named arguments, return a pure array.
+     * @example parse("1, 2, 3") -> [1, 2, 3] (instead of {0: 1, 1: 2, 2: 3})
+     * @default true
+     */
+    purePositionalAsArray?: boolean;
+    /**
+     * [Output Mode]
+     * - 'auto': Apply the simplification flags above (default).
+     * - 'array': Always return an array of positional args. Named args are hidden in the '.namedArgs' property.
+     * - 'object': Always return a merged object with both numeric and string keys.
+     * - 'map': Always return the full structure { args: [], namedArgs: {}, flags: {} }.
+     * @default 'auto'
+     */
+    mode?: 'auto' | 'array' | 'object' | 'map';
+}
+/**
+ * Configuration options for the CmdArgParser and main API functions.
+ */
+interface CmdArgParserOptions {
+    /**
+     * Character used to separate arguments.
+     * @example delimiter: ';' -> "arg1; arg2"
+     * @default ','
+     */
+    delimiter?: string;
+    /**
+     * Character used for name-value assignment.
+     * @example assigner: ':' -> "key:value"
+     * @default '='
+     */
+    assigner?: string;
+    /**
+     * Prefix(es) for special parameters (Flags).
+     * @example flagPrefix: '!' -> "!debug, !verbose=false"
+     */
+    flagPrefix?: string | string[];
+    /** Custom logic to process each argument before standard evaluation */
+    argProcessor?: ArgProcessor;
+    /** Format used by TemplateArgProcessor (e.g., 'mustache') */
+    templateFormat?: string;
+    /** Additional data for template variable substitution */
+    templateData?: Record<string, any>;
+    /**
+     * If true, the positional index of an argument that has been automatically
+     * mapped as a named argument (via `idAsName`) will be excluded from the
+     * merged result object.
      *
-     * @returns A promise resolving to the signal value (type T).
+     * @example parse("John") -> {John: "John"} (instead of {0: "John", John: "John"})
+     */
+    excludeAutoNamedFromPositional?: boolean;
+    /** If true, return the variable name as a string when it's not found in scope instead of undefined */
+    preserveUnresolvedName?: boolean;
+    /**
+     * If true, explicitly named arguments (e.g., `k=v`) do not occupy a slot
+     * in the positional `args` array.
+     * @default true
      */
-    wait(): Promise<T>;
+    namedExcludePositional?: boolean;
+    /**
+     * If true, a positional argument that is a valid identifier (e.g., "John")
+     * is automatically mapped as a named argument (e.g., {John: "John"}).
+     * @default true
+     */
+    idAsName?: boolean;
+    /** If true, JS expressions (like arithmetic or function calls) are not evaluated */
+    skipExpression?: boolean;
+    /** Control the simplification of the final result. Set to `false` to disable (returns a merged object). */
+    simplify?: boolean | CmdArgSimplifyOptions;
+    /** If true, any parsing or evaluation error will be thrown */
+    raiseError?: boolean;
+    /** If true, ReferenceErrors (missing variables) will be thrown. Defaults to `raiseError`. */
+    raiseReferenceError?: boolean;
+    /** An object containing variables accessible to expressions in the input string */
+    scope?: Record<string, any>;
+    /** @internal Used to prevent infinite recursion in internal calls */
+    isInternal?: boolean;
 }
-
 /**
- * Counts the number of matches for a given regular expression in a specified string.
- * This function ensures that the regular expression is used globally by adding the 'g' flag,
- * if it is not already present.
+ * Configuration for AI selection logic (used by ChoiceArgProcessor).
  *
- * @param content - The string to search within.
- * @param regex - The regular expression to use for matching.
- * @returns The total number of matches found.
+ * @example "|item1|item2:maxPick=2"
  */
-declare function countRegexMatches(content: string, regex: RegExp): number;
-
-type ArgInfo = [boolean, string];
-type ArgProcessor = (arg: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions) => string | void | Promise<string | void>;
-interface AIChoiceConfig {
+interface CmdArgAIChoiceConfig {
+    /** List of items to choose from */
     items?: string[];
+    /** Maximum number of items that can be picked */
     maxPick?: number;
+    /** Minimum number of items that must be picked */
     minPick?: number;
+    /** Separator for the resulting choice string */
     separator?: string;
+    /** Prefix to add to the result */
     prefix?: string;
+    /** Suffix to add to the result */
+    suffix?: string;
+    /** Selection strategy: 'random' for random pick, 'ai' for AI-assisted pick */
     type?: 'random' | 'ai';
+    /** Closing character/string for the selection UI */
     end?: string;
 }
-interface ParseObjectArgumentOptions {
-    delimiter?: string;
-    assigner?: string;
-    argProcessor?: ArgProcessor;
-    returnArrayOnly?: boolean;
-    templateFormat?: string;
-    templateData?: Record<string, any>;
-    ignoreIndexNamed?: boolean;
-    preserveUnresolvedName?: boolean;
-    skipExpression?: boolean;
-    raiseError?: boolean;
+/**
+ * The internal structured result of the parsing process.
+ */
+interface CmdArgParseResult {
+    /** Positional arguments array. Indices correspond to the appearance order. */
+    args: any[];
+    /** Named arguments map, combining explicit `k=v`, auto-mapped IDs, and Processor results. */
+    namedArgs: Record<string, any>;
+    /** Special parameters (Flags) map. Values are usually Boolean but can be any type. */
+    flags: CmdArgFlagsRecord;
+    /** A set of numeric indices that were populated by explicitly named arguments. */
+    namedIndices: Set<number>;
+}
+/**
+ * Simplified argument result.
+ * Could be a single value, an array, or an object based on CmdArgSimplifyOptions.
+ */
+type SimplifiedResultType = any;
+/**
+ * Result structure when mode is 'map'.
+ */
+interface CmdArgMapResult {
+    /** Positional arguments array */
+    args: any[];
+    /** Named arguments map */
+    namedArgs: Record<string, any>;
+    /** Special parameters (Flags) map */
+    flags?: CmdArgFlagsRecord;
+}
+/**
+ * The full structure of a parsed command.
+ */
+interface CmdArgParsedCommand {
+    /** The command name (the identifier before the parentheses) */
+    command: string;
+    /** The parsed arguments, either simplified or in map format */
+    args: SimplifiedResultType | CmdArgMapResult;
+    /** Special parameters (Flags) map (if present) */
+    flags?: CmdArgFlagsRecord;
+}
+/**
+ * Normalized argument information, typically used for final consumption.
+ */
+interface CmdArgArgsInfo {
+    /** Positional arguments array */
+    args: any[];
+    /** Named arguments map */
+    namedArgs?: Record<string, any>;
 }
+
+/**
+ * Evaluates the value of an argument.
+ *
+ * Priority:
+ * 1. Attempt to call a custom processor (ArgProcessor).
+ * 2. If the processor returns a source string, recursively call evaluateExpression.
+ * 3. Default to evaluateExpression (handles literals, scope variables, and JS expressions).
+ */
+declare function cmdArgEvaluate(ctx: CmdArgContext): Promise<any>;
+/**
+ * Evaluates an expression string to its value.
+ *
+ * Logic sequence:
+ * 1. Check if evaluation should be skipped.
+ * 2. Match simple JS literals (true, false, null, undefined, NaN, Infinity).
+ * 3. Check if it's a number.
+ * 4. Perform path lookup in the scope (getByPath).
+ * 5. Attempt execution as a JS expression or arrow function.
+ * 6. Catch ReferenceError: Decide whether to fall back to raw text or return undefined based on options.
+ * 7. Final fallback: Handle unquoting for quoted strings.
+ */
+declare function evaluateExpression(code: string, scope: any, options: CmdArgParserOptions): Promise<any>;
+
+/**
+ * Choice argument processor (ChoiceArgProcessor).
+ *
+ * Syntax: |item1|item2:maxPick=2:separator=";"
+ *
+ * Logic:
+ * 1. Identifies positional arguments starting with '|'.
+ * 2. Recursively uses the CmdArgParser to parse subsequent configuration items (delimited by ':').
+ * 3. Constructs an CmdArgAIChoiceConfig object.
+ * 4. Returns the result using the Symbol Protocol, named 'choice' and excluded from positional indexing.
+ */
+declare function ChoiceArgProcessor(ctx: CmdArgContext): Promise<{
+    [CMD_ARG_PROCESSOR_RESULT]: (string | CmdArgAIChoiceConfig | {
+        excludePositional: boolean;
+    })[];
+} | undefined>;
+/**
+ * Template variable processor (TemplateArgProcessor).
+ *
+ * Syntax: msg="Hello {{name}}"
+ *
+ * Logic:
+ * 1. Calls PromptTemplate.formatIf for variable substitution.
+ * 2. If the substitution results in a bare string (no quotes and not JS literal source),
+ *    it is JSON-escaped to ensure it's recognized as a string literal in subsequent evaluation.
+ * 3. Returns the substituted source string for re-evaluation by the Evaluator.
+ */
+declare function TemplateArgProcessor(ctx: CmdArgContext): Promise<{
+    [CMD_ARG_PROCESSOR_RESULT]: any[];
+} | undefined>;
+/**
+ * Combined AI processor (AIArgProcessor).
+ * Sequentially attempts choice selection and template variable processing.
+ */
+declare function AIArgProcessor(ctx: CmdArgContext): Promise<{
+    [CMD_ARG_PROCESSOR_RESULT]: (string | CmdArgAIChoiceConfig | {
+        excludePositional: boolean;
+    })[];
+} | undefined>;
+
 /**
- * Asynchronously parses a string of object arguments into an actual object.
- * @param argsStr The string of arguments to be parsed.
- * @param scope An optional scope object that provides values for variables during parsing.
- * @param options An optional configuration object containing the delimiter and argument processor.
- * @returns The parsed object or undefined.
- *
- * This function first parses the argument string into an object string and then converts it
- * into a proper JavaScript/JSON object based on the parsing results and configuration options.
- * It handles the conversion of single objects, arrays, and key-value pairs. The default delimiter
- * between parameters is a comma (`,`), but this can be customized using the `options.delimiter`.
- * Parameter assignment always uses an equal sign (`=`) and cannot be modified.
- *
- * The function returns:
- * - An object if the input string represents a set of key-value pairs.
- * - An array if the input string represents a sequence of elements, where each element can be
- *   parsed as a number (indices are used as keys).
- * - A single value if the input string represents a single value or a single key-value pair.
- * - `undefined` if the input string is empty or cannot be parsed into a valid object.
+ * Parses an object-style argument string into a structured result.
+ * Supports positional args, named args, JS expressions, and custom processors.
+ *
+ * @param argsStr The argument string to parse.
+ * @param scope Optional evaluation scope for resolving variables.
+ * @param options CmdArgParser configuration options.
+ * @returns The parsed and simplified result.
  *
  * @example
- * ```typescript
- * // Example call with default delimiter
- * const result = await parseObjectArguments("name=John,age=30");
- * console.log(result); // Output: { name: 'John', age: '30' }
+ * ```ts
+ * // 1. Simple positional
+ * await parseObjectArguments("123") // returns 123
  *
- * // Example call with custom delimiter
- * const resultCustomDelimiter = await parseObjectArguments("name=John|age=30", undefined, { delimiter: '|' });
- * console.log(resultCustomDelimiter); // Output: { name: 'John', age: '30' }
+ * // 2. Multiple positional
+ * await parseObjectArguments("1, 2, 3") // returns [1, 2, 3]
  *
- * // Example with a single value
- * const singleValue = await parseObjectArguments("42");
- * console.log(singleValue); // Output: 42
+ * // 3. Named arguments
+ * await parseObjectArguments("name='John', age=25") // returns {name: 'John', age: 25}
  *
- * // Example with an array
- * const arrayResult = await parseObjectArguments("1,2,3");
- * console.log(arrayResult); // Output: [1, 2, 3]
+ * // 4. Mixed (idAsName enabled by default)
+ * await parseObjectArguments("John, age=25") // returns {0: 'John', John: 'John', age: 25}
  * ```
  */
-declare function parseObjectArguments(argsStr: string, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<any>;
-declare function ObjectArgsToArgsInfo(args: any): {
-    args: any[];
-    kvArgs?: Record<string, any>;
-};
-declare function simplifyObjectArguments(args: any): any;
-declare function parseObjectArgumentInfos(args: ArgInfo[], scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<any>;
-declare function ChoiceArgProcessor(argInfo: ArgInfo, _ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): string | undefined;
-declare function TemplateArgProcessor([isNamedArg, arg]: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string | undefined>;
-declare function AIArgProcessor(argInfo: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string | undefined>;
-declare function isQuoted(s: string): boolean;
-declare function isStrWrapped(s: string, pairs?: string[]): boolean;
-declare function ensureQuoted(s: string, quoteChar?: string): string;
-declare function quoteStr(str: string): string;
-declare function parseObjectArgInfo(argInfo: ArgInfo, ix: number, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<string>;
+declare function parseObjectArguments(argsStr: string, scope?: Record<string, any>, options?: CmdArgParserOptions): Promise<SimplifiedResultType | CmdArgMapResult | undefined>;
 /**
- * Parses an object arguments string into an array of ArgInfo.
+ * Merges parsing results into a single flattened object.
+ * Numeric indices are used for positional arguments.
  *
- * This function processes a parameter string and parses it according to specific rules, allowing for custom delimiters.
- * It can handle quotes, escape characters, and expressions within brackets. The parsing is designed to interpret
- * object literal strings from dynamic languages, such as JSON objects or similar custom formats.
+ * @param result The raw parse result.
+ * @param options CmdArgParser configuration options.
+ * @returns A merged object containing all arguments.
+ */
+declare function cmdArgsToMergedObject(result: CmdArgParseResult, options?: CmdArgParserOptions): Record<string | number, any>;
+/**
+ * Simplifies the raw parsing result into a more intuitive format.
+ * The behavior is controlled by `options.simplify`.
  *
- * @param argsStr The string containing the arguments to be parsed.
- * @param scope An optional scope object used for further processing of the parsed arguments. Default is undefined.
- * @param options Parsing options, including:
- *   - delimiter: The character used to separate arguments. Default is ','.
- *   - argProcessor: An optional instance of ArgProcessor used for further processing of the parsed arguments.
- * @returns An array of parsed argument information, where each item contains a boolean indicating whether the argument is named,
- *          and the string representation of the argument.
+ * @param result The raw parse result.
+ * @param options CmdArgParser configuration options.
+ * @returns A simplified value, array, or object.
  */
-declare function parseObjectArgumentsAsArgInfos(argsStr: string, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): ArgInfo[];
-declare function parseCommand(commandStr: string, scope?: Record<string, any>, options?: ParseObjectArgumentOptions): Promise<{
-    command: string;
-    args?: Record<string, any>;
-} | undefined>;
+declare function simplifyResult(result: CmdArgParseResult, options?: CmdArgParserOptions): SimplifiedResultType | CmdArgMapResult;
+/**
+ * Deeply simplifies object-style arguments (recursive convergence).
+ * Useful for normalizing complex argument structures.
+ */
+declare function simplifyObjectArguments(args: any): SimplifiedResultType;
+/**
+ * Normalizes various simplified result formats back into an `{args, namedArgs}` info structure.
+ *
+ * @example
+ * ```ts
+ * ObjectArgsToArgsInfo("val") // returns {args: ["val"]}
+ * ObjectArgsToArgsInfo([1, 2]) // returns {args: [1, 2]}
+ * ObjectArgsToArgsInfo({name: "John"}) // returns {args: [], namedArgs: {name: "John"}}
+ * ```
+ */
+declare function ObjectArgsToArgsInfo(args: any): CmdArgArgsInfo;
+/**
+ * Parses a full command string including the command name and its parenthesized arguments.
+ *
+ * @param commandStr The command string, e.g., 'myCmd(arg1, k=v, !flag)'
+ * @param scope Evaluation scope.
+ * @param options CmdArgParser configuration options.
+ * @returns An object containing the command name, parsed args, and optional flags.
+ *
+ * @example
+ * ```ts
+ * await parseCommand("sum(1, 2)") // returns {command: "sum", args: [1, 2]}
+ * await parseCommand("search(query='abc', !caseSensitive)") // returns {command: "search", args: {query: 'abc'}, flags: {caseSensitive: true}}
+ * ```
+ */
+declare function parseCommand(commandStr: string, scope?: Record<string, any>, options?: CmdArgParserOptions): Promise<CmdArgParsedCommand | undefined>;
+
 interface ReplacePlacehoderOptions {
     startChar?: string | string[];
     endChar?: string | string[];
@@ -1118,36 +1359,60 @@ interface ReplacePlacehoderOptions {
     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.
+ * List of JS reserved words used to filter identifiers that should not be automatically mapped to names.
+ */
+declare const RESERVED_WORDS: string[];
+/**
+ * Unicode-aware JS identifier regex (ES2015+ u flag).
+ * Allows $, _, and Unicode identifier start/continue characters.
+ */
+declare const IDENTIFIER_REGEX: RegExp;
+/**
+ * Regex for dot-separated path identifiers (e.g., test.a.b).
+ */
+declare const PATH_IDENTIFIER_REGEX: RegExp;
+/**
+ * Checks if a string is a valid JS identifier and not a reserved word.
+ * Supports optional flag prefix stripping.
+ */
+declare function isIdentifier(s: string, options?: {
+    flagPrefix?: string | string[];
+}): boolean;
+/**
+ * Wraps a value with a Flag Symbol.
+ * For primitive types (Boolean, String, Number), uses wrapper objects to support
+ * non-enumerable property attachment.
+ */
+declare function wrapFlagValue(value: any, prefix: string): any;
+/**
+ * Checks if a string is a valid path identifier (dot-separated identifiers).
+ */
+declare function isPathIdentifier(s: string): boolean;
+/**
+ * Checks if a string is wrapped in quotes (", ', `).
+ * Leading and trailing whitespace are ignored.
+ */
+declare function isQuoted(s: string): boolean;
+/**
+ * Checks if a string is wrapped by specified character pairs.
+ */
+declare function isStrWrapped(s: string, pairs?: string[]): boolean;
+/**
+ * Ensures a string is wrapped in quotes.
+ */
+declare function ensureQuoted(s: string, quoteChar?: string): string;
+/**
+ * Escapes and wraps a string in double quotes.
+ * Avoids redundant escaping.
+ */
+declare function quoteStr(str: string): string;
+/**
+ * Replaces specific wrapped substrings within a string with placeholders.
+ * Useful for processing strings while ignoring quoted or bracketed content.
  */
 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!"
- * ```
+ * Restores original string content from placeholders.
  */
 declare function restoreFromPlacehoders(content: string, placehoders: string[], options?: ReplacePlacehoderOptions): string;
 
@@ -1238,6 +1503,24 @@ declare function pruneSubdirectories(paths: string[]): string[];
 declare function pruneSubdirectoriesInPlace(paths: string[]): void;
 declare function normalizePath(inputPath: string): string;
 
+/**
+ * Checks if the provided value is a regular expression.
+ *
+ * This function determines whether the given value is a regular expression
+ * by using both string-based and object-based validation methods.
+ *
+ * @param value - The value to be checked for being a regular expression
+ * @returns `true` if the value is a regular expression, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * isRegExp(/abc/); // true
+ * isRegExp(new RegExp('abc')); // true
+ * isRegExp('/abc/'); // true
+ * isRegExp('abc'); // false
+ * isRegExp(123); // false
+ * ```
+ */
 declare function isRegExp(value: any): boolean;
 
 declare function stripConsoleColor(str: any): any;
@@ -1326,6 +1609,13 @@ 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>;
 
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
 /**
 Extract all optional keys from the given type.
 
@@ -2359,132 +2649,118 @@ declare function joinSplitWords(input: string, separator?: string): string;
 declare function splitWords(input: string): string[];
 
 /**
- * Utility to serialize an object into a URL query parameter string.
- * @param objParam The parameter object.
- * @param omitQuestionMark If true, omits the leading '?' from the result. Defaults to false.
- * @returns The URL-encoded query string or an empty string.
- */
-declare function genUrlParamsStr(objParam: any, omitQuestionMark?: boolean): string;
-
-declare class SseServerPubSubTransport implements IPubSubServerTransport {
-    readonly name = "sse";
-    readonly protocol: "sse";
-    private channel;
-    private sessions;
-    private onConn?;
-    private onDis?;
-    connect(options?: {
-        req: IncomingMessage;
-        res: ServerResponse;
-        clientId?: string;
-        events?: string[];
-    }): PubSubServerSession;
-    getSessionFromReq(req: IncomingMessage): PubSubServerSession | undefined;
-    subscribe(session: PubSubServerSession, events: string[]): void;
-    unsubscribe(session: PubSubServerSession, events: string[]): void;
-    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 {
-    private apiRoot;
-    setApiRoot(apiRoot: string): void;
-    connect(url: string, params?: any): Promise<PubSubClientStream>;
-    disconnect(stream: PubSubClientStream): void;
-}
+ * Prepends a newline character to the beginning of the input text if it is multiline and does not already start with a newline.
+ *
+ * This function checks whether the provided text contains multiple lines by looking for newline characters (`\n`).
+ * If the text is determined to be multiline and its first non-whitespace character is not a newline,
+ * a newline character will be added at the beginning of the text.
+ *
+ * @param text - The input string to check and potentially modify.
+ * @returns The processed string, which may have a prepended newline if conditions are met.
+ *
+ * @example
+ * ```typescript
+ * console.log(prependNewlineIfMultiline("  hello\nworld")); // Output: "\n  hello\nworld"
+ * console.log(prependNewlineIfMultiline("\nhello\nworld")); // Output: "\nhello\nworld" (unchanged)
+ * console.log(prependNewlineIfMultiline("single line")); // Output: "single line" (unchanged)
+ * ```
+ */
+declare function prependNewlineIfMultiline(text: string): string;
 
 /**
- * Defines the public interface for a server-side transport,
- * responsible for exposing ServerTools to the network.
+ * 行内化样式模式
+ * - 'auto': 根据阈值自动决定
+ * - 'always': 始终行内化 (除非包含换行符)
+ * - 'never': 始终使用块状样式
  */
-interface IServerToolTransport extends IToolTransport {
-    /**
-     * Mounts the ServerTools registry, creating the necessary API routes.
-     *
-     * This method is responsible for integrating the tool-handling logic with a
-     * running server instance.
-     *
-     * @param serverTools The ServerTools class containing the tool definitions.
-     * @param apiPrefix An optional prefix for all API routes (e.g., '/api').
-     * @param options A container for transport-specific options. For example,
-     *   an HTTP-based transport would expect an `{ server: http.Server }` object
-     *   to attach its route handlers to.
-     */
-    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;
-}
+type TextifyInlineStyleMode = 'auto' | 'always' | 'never';
 /**
- * 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;
-}
-
+ * 字符串引用策略 (是否用引号包裹)
+ * - 'auto': 遇到特殊字符、保留字或数字外观时自动加引号
+ * - 'always': 所有字符串始终加引号
+ * - 'never': 尽可能不加引号
+ */
+type TextifyStringQuoting = 'auto' | 'always' | 'never';
 /**
- * A concrete server transport implementation using Node.js's built-in HTTP server.
- */
-declare class HttpServerToolTransport extends ServerToolTransport {
-    server: http.Server;
-    private discoveryHandlerInfo;
-    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(force?: boolean): Promise<void>;
-    getRaw(): http.Server;
+ * 行内化详细配置
+ */
+interface TextifyInlineOptions {
+    /** 模式 (默认：'auto') */
+    mode?: TextifyInlineStyleMode;
+    /** 自动行内化的字符长度阈值 (默认：40) */
+    threshold?: number;
+    /** 逗号和冒号后是否保留空格 (默认：true) */
+    spaceAfterSeparator?: boolean;
+    /** 括号/大括号内侧是否保留空格 (默认：false) */
+    spaceInBraces?: boolean;
 }
-
 /**
- * A concrete client transport implementation that uses the browser/node `fetch` API.
+ * 文本化配置选项
+ *
+ * @description
+ * 该工具旨在生成易于人类阅读的、类 YAML 格式的文本表示。
+ *
+ * **核心渲染规则：**
+ * 1. **对象数组 (Object Array)**: 采用 YAML 风格的紧凑模式。
+ *    当对象作为数组项时，会忽略对象自身的 `objectPrefix`，并将第一个键值对紧跟在数组前缀 `-` 后。
+ *    示例：`[{a: 1, b: 2}]` -> `- a: 1\n  b: 2`
+ *
+ * 2. **嵌套数组 (Nested Array)**: 采用阶梯式 (Block Style)。
+ *    内层数组会从新的一行开始，并相对于父级缩进。
+ *    示例：`[[1, 2]]` -> `-\n  - 1\n  - 2`
+ *
+ * 3. **多行字符串对齐**: 自动计算前缀和键名的长度，确保多行文本的后续行与首行左对齐。
+ *
+ * **高级特性：**
+ * - **智能行内化 (Inline Style)**: 自动将短对象或数组转换为 `{a: 1}` 格式。
+ * - **混合模式 (Mixed Mode)**: 根据内容长度自动决定嵌套项是行内还是块状显示。
+ * - **自动引用 (Auto Quoting)**: 智能识别需要引号包裹的字符串（包含特殊字符、保留字或数字外观）。
  */
-declare class HttpClientToolTransport extends ClientToolTransport {
+interface TextifyOptions {
+    /** 缩进单位，可以是空格数或具体的字符串 (默认：2 个空格) */
+    indent?: string | number;
+    /** 数组项前缀 (默认：'-') */
+    arrayPrefix?: string;
+    /** 对象键值对前缀 (默认：'*') */
+    objectPrefix?: string;
+    /** 最大递归深度，防止过深 (默认：10) */
+    maxDepth?: number;
     /**
-     * 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.
+     * 是否确保多行字符串强制换行
+     * (默认：false)
      */
-    loadApis(): Promise<Funcs>;
-    _fetch(name: string, args?: any, act?: ActionName | string, subName?: any, fetchOptions?: any): Promise<Response>;
+    ensureNewLineForMultiline?: boolean;
     /**
-     * @internal
-     * A helper to create a structured error from a failed `fetch` response.
-     * @param res - The HTTP response.
-     * @returns A structured error object.
+     * 行内化配置
+     * - 'auto': 基于阈值自动切换 (默认)
+     * - 'always': 强制行内化 (遇到换行符除外)
+     * - 'never': 强制块状化
      */
-    errorFrom(name: string, res: Response): Promise<_isdk_common_error.CommonError>;
-    toObject(res: any, args?: any): Promise<any>;
+    inlineStyle?: TextifyInlineStyleMode | TextifyInlineOptions;
+    /**
+     * 字符串引用策略 (是否加双引号)
+     * - 'auto': 遇到特殊字符 (:, #, [, ], {, }, *, -, ")、首尾空格、保留字或数字外观时自动加引号 (默认)
+     * - 'always': 所有字符串始终加引号
+     * - 'never': 除非结构必须，否则不加引号
+     */
+    stringQuoting?: TextifyStringQuoting;
 }
+/**
+ * 将任意数据转换为易读的类 YAML 文本
+ *
+ * @param data - 要转换的数据
+ * @param options - 配置选项
+ * @returns 格式化后的文本字符串
+ *
+ * @example
+ * ```ts
+ * const text = textify([{ name: 'Alice', age: 20 }, { name: 'Bob' }]);
+ * // 输出:
+ * // - name: Alice
+ * //   age: 20
+ * // - name: Bob
+ * ```
+ */
+declare function textify(data: any, options?: TextifyOptions): string;
 
-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 SSEClient, type SectionStringOptions, ServerToolTransport, ServerTools, SignalGate, type SplitSentenceOptions, SseClientPubSubTransport, SseServerPubSubTransport, StrangeHumanName, type StreamCallbacksAndOptions, TemplateArgProcessor, ToolTransport, type UUIDVersions, 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 };
+export { AIArgProcessor, type AIChatAssistantMessageParam, type AIChatContentPart, type AIChatContentPartBase, type AIChatContentPartImage, type AIChatContentPartText, type AIChatMessageParam, type AIChatMessageParamBase, type AIChatMessageToolCall, type AIChatRole, AIChatRoles, type AIChatSystemMessageParam, type AIChatTemplateCaps, type AIChatToolChoiceFuncObject, type AIChatToolChoiceObject, type AIChatToolChoiceParam, type AIChatToolDefinition, type AIChatToolFunc, type AIChatToolFuncParam, type AIChatToolMessageParam, type AIChatToolParam, type AIChatToolTypeObject, type AIChatUserMessageParam, type AIMessageType, AIMessageTypes, type AIModelNameRule, type AIModelNameRuleFn, type AIModelNameRules, type AIResult, AIStream, type AIStreamParser, type AIStreamParserOptions, type AITextGenerationFinishReason, AITextGenerationFinishReasons, type ArgProcessor, ArrayMergeWay, ArrayMergeWaySymbol, type BeforeShutdownListener, CMD_ARG_FLAG_SYMBOL, CMD_ARG_PROCESSOR_RESULT, CMD_ARG_UNRESOLVED_SYMBOL, ChoiceArgProcessor, type CmdArgAIChoiceConfig, type CmdArgArgsInfo, type CmdArgContext, type CmdArgFlagMetadata, type CmdArgFlagValue, type CmdArgFlagsRecord, CmdArgLexer, type CmdArgMapResult, type CmdArgParseResult, type CmdArgParsedCommand, CmdArgParser, type CmdArgParserOptions, type CmdArgProcessorResultOptions, type CmdArgSimplifyOptions, type CmdArgToken, CmdArgTokenType, DEFAULT_CONFIG_NAME, DefaultDateFormat, FewShotPromptTemplate, type FewShotPromptTemplateOptions, IDENTIFIER_REGEX, type IFileMetaInfo, type IReadTextFileChunksOptions, type ITruncateToTokenLimitOptions, type JsonFilter, LLM_TOKENIZER_NAMES, LLM_TOKENIZER_NAMES_MAP, ObjectArgsToArgsInfo, PASSING_SCORE, PATH_IDENTIFIER_REGEX, type ProbabilityItem, PromptExampleSelector, type PromptExampleSelectorOptions, type PromptExamples, RESERVED_WORDS, RStreamErrCode, ReadableStreamError, type ReplacePlacehoderOptions, ResponseRStreamErrCode, SHUTDOWN_SIGNALS, type SectionStringOptions, type SimplifiedResultType, type SplitSentenceOptions, StrangeHumanName, TemplateArgProcessor, type TextifyInlineOptions, type TextifyInlineStyleMode, type TextifyOptions, type TextifyStringQuoting, YamlTypeBaseObject, assignDirs, beforeShutdown, calcPerplexity, calcPerplexitySimple, cmdArgEvaluate, cmdArgsToMergedObject, completeSentences, concatText, countLLMTokens, countRegexMatches, createEmptyReadableStream, createEndWithRepetitionDetector, createEventStreamTransformer, createYamlObjectTag, dateToText, decodeCharset, defaultsWithConcat, detectCharset, encodeLLMTokens, ensureQuoted, evaluateExpression, expandConfig, expandPath, expandPathInObject, expandPaths, fileIsExists, filterValidFnScope, findIndexNonEmptyFrom, formatTextWithSpace, getAllEnumKeys, getConfigFileNames, getConfigs, getFileMetaInfo, getHashAlgoBySize, getKeysPath, getLLMTokenizer, getPackageDir, getRealFilepath, getResponseErrorReadableStream, getXDGConfigs, hasDirectoryIn, hashFile, initShutdown, isIdentifier, isLangUsingSpaces, isListItemString, isModelNameMatched, isPathIdentifier, 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, parseObjectArguments, prependNewlineIfMultiline, pruneSubdirectories, pruneSubdirectoriesInPlace, quoteStr, readFilenamesRecursiveSync, readTextFileChunks, readTextFileChunksEx, readableFromAsyncIterable, removeMarkdownBold, removeMarkdownBoldAndItalic, removeMarkdownItalic, replaceWithPlaceholder, restoreFromPlacehoders, saveConfigFile, scaleStrToParamsSize, shutdown, simplifyObjectArguments, simplifyResult, sortedValues, splitChunks, splitParagraph, splitSentence, splitWords, stripConsoleColor, textToDate, textify, toDateTime, trimStartOfStreamHelper, truncTo, truncateByToken, truncateToTokenLimit, truncateToTokenLimitEx, wait, wrapFlagValue };