@agentica/core 0.14.2 → 0.15.0

package/lib/index.mjs

@@ -1,128 +1,14 @@
-import { HttpLlm, ChatGptTypeChecker, OpenApi } from "@samchon/openapi";
-
-import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
 
 import "typia";
 
 import { v4 } from "uuid";
 
-import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
-
-import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
-
-var AgenticaConstant;
-
-(function(AgenticaConstant) {
-    AgenticaConstant.RETRY = 3;
-    AgenticaConstant.ELITICISM = true;
-})(AgenticaConstant || (AgenticaConstant = {}));
-
-const AgenticaSystemPrompt = {
-    CANCEL: "You are a helpful assistant for cancelling functions which are prepared to call.\n\nUse the supplied tools to select some functions to cancel of `getApiFunctions()` returned.\n\nIf you can't find any proper function to select, don't talk, don't do anything.",
-    COMMON: 'At first, the user\'s language locale code is "${locale}". When you are conversating with the user or describing the function calling result, consider it and always translate to the target locale language. Never conversate with different locale language text with the user.\n\nAt second, the user\'s timezone is "${timezone}", and ISO datetime is ${datetime}. When you are conversating with the user, consider current time and user belonged timezone.',
-    DESCRIBE: "You are a helpful assistant describing return values of function calls.\n\nAbove messages are the list of function call histories. When describing the return values, please do not too much shortly summarize them. Instead, provide detailed descriptions as much as.\n\nAlso, its content format must be markdown. If required, utilize the mermaid syntax for drawing some diagrams. When image contents are, just put them through the markdown image syntax.\n\nAt last, if user's language locale code is different with your description, please translate it to the user's language.",
-    EXECUTE: 'You are a helpful assistant for tool calling.\n\nUse the supplied tools to assist the user.\n\nIf previous messages are not enough to compose the arguments, you can ask the user to write more information. By the way, when asking the user to write more information, make the text concise and clear.\n\nFor reference, in the "tool" role message content, the `function` property means metadata of the API operation. In other words, it is the function schema describing its purpose, parameters and return value types. And then the `data` property is the return value from the target function calling.',
-    INITIALIZE: "You are a helpful assistant.\n\nUse the supplied tools to assist the user.",
-    SELECT: "You are a helpful assistant for selecting functions to call.\n\nUse the supplied tools to select some functions of `getApiFunctions()` returned.\n\nWhen selecting functions to call, pay attention to the relationship between functions. In particular, check the prerequisites between each function.\n\nIf you can't find any proper function to select, just type your own message. By the way, when typing your own message, please consider the user's language locale code. If your message is different with the user's language, please translate it to the user's."
-};
-
-const NOT_MOUNTED_YET = {};
-
-class Singleton {
-    constructor(closure) {
-        this.closure_ = closure;
-        this.value_ = NOT_MOUNTED_YET;
-    }
-    get(...args) {
-        if (this.value_ === NOT_MOUNTED_YET) {
-            this.value_ = this.closure_(...args);
-        }
-        return this.value_;
-    }
-}
-
-const isNode = new Singleton((() => {
-    const isObject = obj => typeof obj === "object" && obj !== null;
-    return typeof global === "object" && isObject(global) && isObject(global.process) && isObject(global.process.versions) && typeof global.process.versions.node !== "undefined";
-}));
-
-const getLocale = new Singleton((() => isNode.get() ? process.env.LANG?.split(".")[0] ?? "en-US" : navigator.language));
-
-const getTimezone = new Singleton((() => Intl.DateTimeFormat().resolvedOptions().timeZone));
-
-function write(config) {
-    if (config?.systemPrompt?.common !== undefined) {
-        return config?.systemPrompt?.common(config);
-    }
-    const locale = config?.locale ?? getLocale.get();
-    const timezone = config?.timezone ?? getTimezone.get();
-    return AgenticaSystemPrompt.COMMON.replace("${locale}", locale).replace("${timezone}", timezone);
-}
-
-const AgenticaDefaultPrompt = {
-    write
-};
-
-async function readAll(stream) {
-    const reader = stream.getReader();
-    const result = [];
-    while (true) {
-        const {done, value} = await reader.read();
-        if (done) {
-            break;
-        }
-        result.push(value);
-    }
-    return result;
-}
-
-async function reduce(stream, reducer, initial) {
-    const reader = stream.getReader();
-    let acc = initial ?? null;
-    while (true) {
-        const {done, value} = await reader.read();
-        if (done) {
-            break;
-        }
-        if (acc === null) {
-            acc = value;
-            continue;
-        }
-        acc = reducer(acc, value);
-    }
-    return acc;
-}
-
-function to(value) {
-    const stream = new ReadableStream({
-        start: controller => {
-            controller.enqueue(value);
-            controller.close();
-        }
-    });
-    return stream;
-}
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
 
-function transform$1(stream, transformer) {
-    const reader = stream.getReader();
-    return new ReadableStream({
-        pull: async controller => {
-            const {done, value} = await reader.read();
-            if (!done) {
-                controller.enqueue(transformer(value));
-            } else {
-                controller.close();
-            }
-        }
-    });
-}
+import { HttpLlm, ChatGptTypeChecker, OpenApi } from "@samchon/openapi";
 
-const StreamUtil = {
-    readAll,
-    reduce,
-    to,
-    transform: transform$1
-};
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 
 var ByteArrayUtil;
 
@@ -172,7 +58,7 @@ function sum(x, y) {
     };
 }
 
-const ChatGptUsageAggregator = {
+const ChatGptTokenUsageAggregator = {
     sum,
     sumCompletionTokenDetail,
     sumPromptTokenDetail
@@ -620,7 +506,7 @@ function accumulate(origin, chunk) {
         if (origin.usage == null) {
             return chunk.usage;
         }
-        return ChatGptUsageAggregator.sum(origin.usage, chunk.usage);
+        return ChatGptTokenUsageAggregator.sum(origin.usage, chunk.usage);
     })();
     return {
         ...origin,
@@ -707,74 +593,320 @@ const ChatGptCompletionMessageUtil = {
     mergeToolCalls
 };
 
-function decode(history) {
-    if (history.type === "describe") {
-        return [];
-    } else if (history.type === "text") {
-        return [ {
-            role: history.role,
-            content: history.text
-        } ];
-    } else if (history.type === "select" || history.type === "cancel") {
-        return [ {
-            role: "assistant",
-            tool_calls: [ {
-                type: "function",
-                id: history.id,
-                function: {
-                    name: `${history.type}Functions`,
-                    arguments: JSON.stringify({
-                        functions: history.selections.map((s => ({
-                            name: s.operation.function.name,
-                            reason: s.reason
-                        })))
-                    })
-                }
-            } ]
-        }, {
-            role: "tool",
-            tool_call_id: history.id,
-            content: ""
-        } ];
+class AgenticaTokenUsage {
+    constructor(props) {
+        if (props === undefined) {
+            const zero = AgenticaTokenUsage.zero();
+            this.aggregate = zero.aggregate;
+            this.initialize = zero.initialize;
+            this.select = zero.select;
+            this.cancel = zero.cancel;
+            this.call = zero.call;
+            this.describe = zero.describe;
+        } else {
+            this.aggregate = props.aggregate;
+            this.initialize = props.initialize;
+            this.select = props.select;
+            this.cancel = props.cancel;
+            this.call = props.call;
+            this.describe = props.describe;
+        }
     }
-    return [ {
-        role: "assistant",
-        tool_calls: [ {
-            type: "function",
-            id: history.id,
-            function: {
-                name: history.operation.name,
-                arguments: JSON.stringify(history.arguments)
-            }
-        } ]
-    }, {
-        role: "tool",
-        tool_call_id: history.id,
-        content: JSON.stringify({
-            function: {
-                protocol: history.operation.protocol,
-                description: history.operation.function.description,
-                parameters: history.operation.function.parameters,
-                output: history.operation.function.output,
-                ...history.operation.protocol === "http" ? {
-                    method: history.operation.function.method,
-                    path: history.operation.function.path
-                } : {}
+    increment(y) {
+        const increment = (x, y) => {
+            x.total += y.total;
+            x.input.total += y.input.total;
+            x.input.cached += y.input.cached;
+            x.output.total += y.output.total;
+            x.output.reasoning += y.output.reasoning;
+            x.output.accepted_prediction += y.output.accepted_prediction;
+            x.output.rejected_prediction += y.output.rejected_prediction;
+        };
+        increment(this.aggregate, y.aggregate);
+        increment(this.initialize, y.initialize);
+        increment(this.select, y.select);
+        increment(this.cancel, y.cancel);
+        increment(this.call, y.call);
+        increment(this.describe, y.describe);
+    }
+    toJSON() {
+        return (() => {
+            const _co0 = input => ({
+                aggregate: _co1(input.aggregate),
+                initialize: _co1(input.initialize),
+                select: _co1(input.select),
+                cancel: _co1(input.cancel),
+                call: _co1(input.call),
+                describe: _co1(input.describe)
+            });
+            const _co1 = input => ({
+                total: input.total,
+                input: _co2(input.input),
+                output: _co3(input.output)
+            });
+            const _co2 = input => ({
+                total: input.total,
+                cached: input.cached
+            });
+            const _co3 = input => ({
+                total: input.total,
+                reasoning: input.reasoning,
+                accepted_prediction: input.accepted_prediction,
+                rejected_prediction: input.rejected_prediction
+            });
+            return input => _co0(input);
+        })()(this);
+    }
+    static zero() {
+        const component = () => ({
+            total: 0,
+            input: {
+                total: 0,
+                cached: 0
             },
-            ...history.operation.protocol === "http" ? {
-                status: history.value.status,
-                data: history.value.body
-            } : {
-                value: history.value
+            output: {
+                total: 0,
+                reasoning: 0,
+                accepted_prediction: 0,
+                rejected_prediction: 0
             }
-        })
-    } ];
-}
-
-const ChatGptHistoryDecoder = {
-    decode
+        });
+        return new AgenticaTokenUsage({
+            aggregate: component(),
+            initialize: component(),
+            select: component(),
+            cancel: component(),
+            call: component(),
+            describe: component()
+        });
+    }
+    static plus(x, y) {
+        const z = new AgenticaTokenUsage(x);
+        z.increment(y.toJSON());
+        return z;
+    }
+}
+
+function aggregate(props) {
+    const component = props.usage[props.kind];
+    component.total += props.completionUsage.total_tokens;
+    component.input.total += props.completionUsage.prompt_tokens;
+    component.input.total += props.completionUsage.prompt_tokens_details?.audio_tokens ?? 0;
+    component.input.cached += props.completionUsage.prompt_tokens_details?.cached_tokens ?? 0;
+    component.output.total += props.completionUsage.completion_tokens;
+    component.output.accepted_prediction += props.completionUsage.completion_tokens_details?.accepted_prediction_tokens ?? 0;
+    component.output.reasoning += props.completionUsage.completion_tokens_details?.reasoning_tokens ?? 0;
+    component.output.rejected_prediction += props.completionUsage.completion_tokens_details?.rejected_prediction_tokens ?? 0;
+    const sum = getter => Object.entries(props.usage).filter((([key]) => key !== "aggregate")).map((([, comp]) => getter(comp))).reduce(((a, b) => a + b), 0);
+    const aggregate = props.usage.aggregate;
+    aggregate.total = sum((comp => comp.total));
+    aggregate.input.total = sum((comp => comp.input.total));
+    aggregate.input.cached = sum((comp => comp.input.cached));
+    aggregate.output.total = sum((comp => comp.output.total));
+    aggregate.output.reasoning = sum((comp => comp.output.reasoning));
+    aggregate.output.accepted_prediction = sum((comp => comp.output.accepted_prediction));
+    aggregate.output.rejected_prediction = sum((comp => comp.output.rejected_prediction));
+}
+
+const AgenticaTokenUsageAggregator = {
+    aggregate
+};
+
+function __map_take(dict, key, generator) {
+    const oldbie = dict.get(key);
+    if (oldbie !== undefined) {
+        return oldbie;
+    }
+    const value = generator();
+    dict.set(key, value);
+    return value;
+}
+
+function compose(props) {
+    const unique = props.controllers.length === 1 || (() => {
+        const names = props.controllers.map((controller => controller.application.functions.map((func => func.name)))).flat();
+        return new Set(names).size === names.length;
+    })();
+    const naming = (func, ci) => unique ? func : `_${ci}_${func}`;
+    const array = props.controllers.map(((controller, ci) => controller.protocol === "http" ? controller.application.functions.map((func => ({
+        protocol: "http",
+        controller,
+        function: func,
+        name: naming(func.name, ci),
+        toJSON: () => ({
+            protocol: "http",
+            controller: controller.name,
+            function: func.name,
+            name: naming(func.name, ci)
+        })
+    }))) : controller.application.functions.map((func => ({
+        protocol: "class",
+        controller,
+        function: func,
+        name: naming(func.name, ci),
+        toJSON: () => ({
+            protocol: "class",
+            controller: controller.name,
+            function: func.name,
+            name: naming(func.name, ci)
+        })
+    }))))).flat();
+    const divided = props.config?.capacity !== undefined && array.length > props.config.capacity ? divide({
+        array,
+        capacity: props.config.capacity
+    }) : undefined;
+    const flat = new Map;
+    const group = new Map;
+    for (const item of array) {
+        flat.set(item.name, item);
+        __map_take(group, item.controller.name, (() => new Map)).set(item.name, item);
+    }
+    return {
+        array,
+        divided,
+        flat,
+        group
+    };
+}
+
+function divide(props) {
+    const size = Math.ceil(props.array.length / props.capacity);
+    const capacity = Math.ceil(props.array.length / size);
+    const replica = props.array.slice();
+    return Array.from({
+        length: size
+    }, (() => replica.splice(0, capacity)));
+}
+
+const AgenticaOperationComposer = {
+    compose
+};
+
+async function readAll(stream) {
+    const reader = stream.getReader();
+    const result = [];
+    while (true) {
+        const {done, value} = await reader.read();
+        if (done) {
+            break;
+        }
+        result.push(value);
+    }
+    return result;
+}
+
+async function reduce(stream, reducer, initial) {
+    const reader = stream.getReader();
+    let acc = initial ?? null;
+    while (true) {
+        const {done, value} = await reader.read();
+        if (done) {
+            break;
+        }
+        if (acc === null) {
+            acc = value;
+            continue;
+        }
+        acc = reducer(acc, value);
+    }
+    return acc;
+}
+
+function to(value) {
+    const stream = new ReadableStream({
+        start: controller => {
+            controller.enqueue(value);
+            controller.close();
+        }
+    });
+    return stream;
+}
+
+function transform$1(stream, transformer) {
+    const reader = stream.getReader();
+    return new ReadableStream({
+        pull: async controller => {
+            const {done, value} = await reader.read();
+            if (!done) {
+                controller.enqueue(transformer(value));
+            } else {
+                controller.close();
+            }
+        }
+    });
+}
+
+const StreamUtil = {
+    readAll,
+    reduce,
+    to,
+    transform: transform$1
 };
 
+function decodePrompt(history) {
+    if (history.type === "describe") {
+        return [];
+    } else if (history.type === "text") {
+        return [ {
+            role: history.role,
+            content: history.text
+        } ];
+    } else if (history.type === "select" || history.type === "cancel") {
+        return [ {
+            role: "assistant",
+            tool_calls: [ {
+                type: "function",
+                id: history.id,
+                function: {
+                    name: `${history.type}Functions`,
+                    arguments: JSON.stringify({
+                        functions: history.selections.map((s => ({
+                            name: s.operation.function.name,
+                            reason: s.reason
+                        })))
+                    })
+                }
+            } ]
+        }, {
+            role: "tool",
+            tool_call_id: history.id,
+            content: ""
+        } ];
+    }
+    return [ {
+        role: "assistant",
+        tool_calls: [ {
+            type: "function",
+            id: history.id,
+            function: {
+                name: history.operation.name,
+                arguments: JSON.stringify(history.arguments)
+            }
+        } ]
+    }, {
+        role: "tool",
+        tool_call_id: history.id,
+        content: JSON.stringify({
+            function: {
+                protocol: history.operation.protocol,
+                description: history.operation.function.description,
+                parameters: history.operation.function.parameters,
+                output: history.operation.function.output,
+                ...history.operation.protocol === "http" ? {
+                    method: history.operation.function.method,
+                    path: history.operation.function.path
+                } : {}
+            },
+            ...history.operation.protocol === "http" ? {
+                status: history.value.status,
+                data: history.value.body
+            } : {
+                value: history.value
+            }
+        })
+    } ];
+}
+
 function createTextPrompt(props) {
     const prompt = {
         type: "text",
@@ -845,25 +977,134 @@ function createExecutePrompt(props) {
     };
 }
 
-function createInitializeEvent() {
-    const event = {
-        type: "initialize"
-    };
+function createOperationSelection(props) {
     return {
-        type: event.type,
-        toJSON: () => event
+        operation: props.operation,
+        reason: props.reason,
+        toJSON: () => ({
+            operation: props.operation.toJSON(),
+            reason: props.reason
+        })
     };
 }
 
-function createSelectEvent(props) {
-    return {
-        type: "select",
-        selection: props.selection,
-        toJSON: () => ({
-            type: "select",
-            selection: props.selection.toJSON()
-        }),
-        toPrompt: () => createSelectPrompt({
+function transform(props) {
+    if (props.prompt.type === "text") {
+        return transformText({
+            prompt: props.prompt
+        });
+    } else if (props.prompt.type === "select") {
+        return transformSelect({
+            operations: props.operations,
+            prompt: props.prompt
+        });
+    } else if (props.prompt.type === "cancel") {
+        return transformCancel({
+            operations: props.operations,
+            prompt: props.prompt
+        });
+    } else if (props.prompt.type === "execute") {
+        return transformExecute({
+            operations: props.operations,
+            prompt: props.prompt
+        });
+    } else if (props.prompt.type === "describe") {
+        return transformDescribe({
+            operations: props.operations,
+            prompt: props.prompt
+        });
+    }
+    throw new Error("Invalid prompt type.");
+}
+
+function transformText(props) {
+    return createTextPrompt(props.prompt);
+}
+
+function transformSelect(props) {
+    return createSelectPrompt({
+        id: props.prompt.id,
+        selections: props.prompt.selections.map((select => createOperationSelection({
+            operation: findOperation({
+                operations: props.operations,
+                input: select.operation
+            }),
+            reason: select.reason
+        })))
+    });
+}
+
+function transformCancel(props) {
+    return createCancelPrompt({
+        id: props.prompt.id,
+        selections: props.prompt.selections.map((select => createOperationSelection({
+            operation: findOperation({
+                operations: props.operations,
+                input: select.operation
+            }),
+            reason: select.reason
+        })))
+    });
+}
+
+function transformExecute(props) {
+    return createExecutePrompt({
+        id: props.prompt.id,
+        operation: findOperation({
+            operations: props.operations,
+            input: props.prompt.operation
+        }),
+        arguments: props.prompt.arguments,
+        value: props.prompt.value
+    });
+}
+
+function transformDescribe(props) {
+    return createDescribePrompt({
+        text: props.prompt.text,
+        executes: props.prompt.executes.map((next => transformExecute({
+            operations: props.operations,
+            prompt: next
+        })))
+    });
+}
+
+function findOperation(props) {
+    const found = props.operations.get(props.input.controller)?.get(props.input.function);
+    if (found === undefined) {
+        throw new Error(`No operation found: (controller: ${props.input.controller}, function: ${props.input.function})`);
+    }
+    return found;
+}
+
+const AgenticaPromptTransformer = {
+    transform,
+    transformText,
+    transformSelect,
+    transformCancel,
+    transformExecute,
+    transformDescribe
+};
+
+function createInitializeEvent() {
+    const event = {
+        type: "initialize"
+    };
+    return {
+        type: event.type,
+        toJSON: () => event
+    };
+}
+
+function createSelectEvent(props) {
+    return {
+        type: "select",
+        selection: props.selection,
+        toJSON: () => ({
+            type: "select",
+            selection: props.selection.toJSON()
+        }),
+        toPrompt: () => createSelectPrompt({
             id: v4(),
             selections: [ props.selection ]
         })
@@ -1001,150 +1242,232 @@ function createResponseEvent(props) {
     };
 }
 
-function createOperationSelection(props) {
-    return {
-        operation: props.operation,
-        reason: props.reason,
-        toJSON: () => ({
-            operation: props.operation.toJSON(),
-            reason: props.reason
-        })
-    };
-}
-
-const CONTAINER$1 = {
-    functions: [ {
-        name: "cancelFunctions",
-        parameters: {
-            description: " Properties of the function\n\n------------------------------\n\nCurrent Type: {@link __IChatFunctionReference.IProps}",
-            type: "object",
-            properties: {
-                functions: {
-                    title: "List of target functions",
-                    description: "List of target functions.",
-                    type: "array",
-                    items: {
-                        description: "Current Type: {@link ___IChatFunctionReference}",
-                        type: "object",
-                        properties: {
-                            reason: {
-                                title: "The reason of the function selection",
-                                description: "The reason of the function selection.\n\nJust write the reason why you've determined to select this function.",
-                                type: "string"
-                            },
-                            name: {
-                                title: "Name of the target function to call",
-                                description: "Name of the target function to call.",
-                                type: "string"
-                            }
-                        },
-                        required: [ "reason", "name" ]
-                    }
-                }
-            },
-            required: [ "functions" ],
-            additionalProperties: false,
-            $defs: {}
-        },
-        description: "Cancel a function from the candidate list to call.\n\nIf you A.I. agent has understood that the user wants to cancel\nsome candidate functions to call from the conversation, please cancel\nthem through this function.\n\nAlso, when you A.I. find a function that has been selected by the candidate\npooling, cancel the function by calling this function. For reference, the\ncandidate pooling means that user wants only one function to call, but you A.I.\nagent selects multiple candidate functions because the A.I. agent can't specify\nonly one thing due to lack of specificity or homogeneity of candidate functions.\n\nAdditionally, if you A.I. agent wants to cancel same function multiply, you can\ndo it by assigning the same function name multiply in the `functions` property.",
-        validate: (() => {
-            const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
-            const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
-            const _vo0 = (input, _path, _exceptionable = true) => [ (Array.isArray(input.functions) || _report(_exceptionable, {
-                path: _path + ".functions",
-                expected: "Array<___IChatFunctionReference>",
-                value: input.functions
-            })) && input.functions.map(((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                path: _path + ".functions[" + _index2 + "]",
-                expected: "___IChatFunctionReference",
-                value: elem
-            })) && _vo1(elem, _path + ".functions[" + _index2 + "]", _exceptionable) || _report(_exceptionable, {
-                path: _path + ".functions[" + _index2 + "]",
-                expected: "___IChatFunctionReference",
-                value: elem
-            }))).every((flag => flag)) || _report(_exceptionable, {
-                path: _path + ".functions",
-                expected: "Array<___IChatFunctionReference>",
-                value: input.functions
-            }) ].every((flag => flag));
-            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.reason || _report(_exceptionable, {
-                path: _path + ".reason",
-                expected: "string",
-                value: input.reason
-            }), "string" === typeof input.name || _report(_exceptionable, {
-                path: _path + ".name",
-                expected: "string",
-                value: input.name
-            }) ].every((flag => flag));
-            const __is = input => "object" === typeof input && null !== input && _io0(input);
-            let errors;
-            let _report;
-            return input => {
-                if (false === __is(input)) {
-                    errors = [];
-                    _report = __typia_transform__validateReport._validateReport(errors);
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "__IChatFunctionReference.IProps",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "__IChatFunctionReference.IProps",
-                        value: input
-                    }))(input, "$input", true);
-                    const success = 0 === errors.length;
-                    return success ? {
-                        success,
-                        data: input
-                    } : {
-                        success,
-                        errors,
-                        data: input
-                    };
-                }
-                return {
-                    success: true,
-                    data: input
-                };
-            };
-        })()
-    } ]
+const AgenticaSystemPrompt = {
+    CANCEL: "You are a helpful assistant for cancelling functions which are prepared to call.\n\nUse the supplied tools to select some functions to cancel of `getApiFunctions()` returned.\n\nIf you can't find any proper function to select, don't talk, don't do anything.",
+    COMMON: 'At first, the user\'s language locale code is "${locale}". When you are conversating with the user or describing the function calling result, consider it and always translate to the target locale language. Never conversate with different locale language text with the user.\n\nAt second, the user\'s timezone is "${timezone}", and ISO datetime is ${datetime}. When you are conversating with the user, consider current time and user belonged timezone.',
+    DESCRIBE: "You are a helpful assistant describing return values of function calls.\n\nAbove messages are the list of function call histories. When describing the return values, please do not too much shortly summarize them. Instead, provide detailed descriptions as much as.\n\nAlso, its content format must be markdown. If required, utilize the mermaid syntax for drawing some diagrams. When image contents are, just put them through the markdown image syntax.\n\nAt last, if user's language locale code is different with your description, please translate it to the user's language.",
+    EXECUTE: 'You are a helpful assistant for tool calling.\n\nUse the supplied tools to assist the user.\n\nIf previous messages are not enough to compose the arguments, you can ask the user to write more information. By the way, when asking the user to write more information, make the text concise and clear.\n\nFor reference, in the "tool" role message content, the `function` property means metadata of the API operation. In other words, it is the function schema describing its purpose, parameters and return value types. And then the `data` property is the return value from the target function calling.',
+    INITIALIZE: "You are a helpful assistant.\n\nUse the supplied tools to assist the user.",
+    SELECT: "You are a helpful assistant for selecting functions to call.\n\nUse the supplied tools to select some functions of `getApiFunctions()` returned.\n\nWhen selecting functions to call, pay attention to the relationship between functions. In particular, check the prerequisites between each function.\n\nIf you can't find any proper function to select, just type your own message. By the way, when typing your own message, please consider the user's language locale code. If your message is different with the user's language, please translate it to the user's."
 };
 
-async function execute$4(ctx) {
-    if (ctx.operations.divided === undefined) {
-        return step$1(ctx, ctx.operations.array, 0);
+const NOT_MOUNTED_YET = {};
+
+class Singleton {
+    constructor(closure) {
+        this.closure_ = closure;
+        this.value_ = NOT_MOUNTED_YET;
     }
-    const stacks = ctx.operations.divided.map((() => []));
-    const events = [];
-    const prompts = await Promise.all(ctx.operations.divided.map((async (operations, i) => step$1({
-        ...ctx,
-        stack: stacks[i],
-        dispatch: async e => {
-            events.push(e);
+    get(...args) {
+        if (this.value_ === NOT_MOUNTED_YET) {
+            this.value_ = this.closure_(...args);
         }
-    }, operations, 0))));
-    if (stacks.every((s => s.length === 0))) {
-        return prompts[0];
-    } else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) {
-        return step$1(ctx, stacks.flat().map((s => ctx.operations.group.get(s.operation.controller.name).get(s.operation.function.name))), 0);
+        return this.value_;
     }
-    const collection = createCancelPrompt({
-        id: v4(),
-        selections: []
-    });
-    for (const e of events) {
-        if (e.type === "select") {
-            collection.selections.push(e.selection);
-            await cancelFunction(ctx, {
-                name: e.selection.operation.name,
-                reason: e.selection.reason
+}
+
+const isNode = new Singleton((() => {
+    const isObject = obj => typeof obj === "object" && obj !== null;
+    return typeof global === "object" && isObject(global) && isObject(global.process) && isObject(global.process.versions) && typeof global.process.versions.node !== "undefined";
+}));
+
+const getLocale = new Singleton((() => isNode.get() ? process.env.LANG?.split(".")[0] ?? "en-US" : navigator.language));
+
+const getTimezone = new Singleton((() => Intl.DateTimeFormat().resolvedOptions().timeZone));
+
+function write(config) {
+    if (config?.systemPrompt?.common !== undefined) {
+        return config?.systemPrompt?.common(config);
+    }
+    const locale = config?.locale ?? getLocale.get();
+    const timezone = config?.timezone ?? getTimezone.get();
+    return AgenticaSystemPrompt.COMMON.replace("${locale}", locale).replace("${timezone}", timezone);
+}
+
+const AgenticaDefaultPrompt = {
+    write
+};
+
+class AsyncQueue {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.closeResolvers = [];
+        this.emptyResolvers = [];
+        this.closed = false;
+    }
+    enqueue(item) {
+        this.queue.push(item);
+        if (this.resolvers.length > 0) {
+            this.resolvers.shift()?.({
+                value: this.queue.shift(),
+                done: false
             });
         }
     }
-    return [ collection ];
+    async dequeue() {
+        if (this.queue.length > 0) {
+            return {
+                value: this.queue.shift(),
+                done: false
+            };
+        }
+        if (this.closed) {
+            if (this.emptyResolvers.length > 0) {
+                this.emptyResolvers.forEach((resolve => resolve()));
+                this.emptyResolvers = [];
+            }
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+        return new Promise((resolve => this.resolvers.push(resolve)));
+    }
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+    isClosed() {
+        return this.closed;
+    }
+    done() {
+        return this.isClosed() && this.isEmpty();
+    }
+    close() {
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()?.({
+                value: undefined,
+                done: true
+            });
+        }
+        this.closeResolvers.forEach((resolve => resolve()));
+    }
+    async waitUntilEmpty() {
+        if (this.isEmpty()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve => {
+            this.emptyResolvers.push(resolve);
+        }));
+    }
+    async waitClosed() {
+        if (this.isClosed()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve => {
+            this.closeResolvers.push(resolve);
+        }));
+    }
+}
+
+class MPSC {
+    constructor() {
+        this.queue = new AsyncQueue;
+        this.consumer = new ReadableStream({
+            pull: async controller => {
+                const {value, done} = await this.queue.dequeue();
+                if (done === true) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+        });
+    }
+    produce(chunk) {
+        this.queue.enqueue(chunk);
+    }
+    close() {
+        this.queue.close();
+    }
+    done() {
+        return this.queue.done();
+    }
+    async waitClosed() {
+        await this.queue.waitClosed();
+    }
+    async waitUntilEmpty() {
+        await this.queue.waitUntilEmpty();
+    }
+}
+
+async function describe(ctx, histories) {
+    if (histories.length === 0) {
+        return [];
+    }
+    const completionStream = await ctx.request("describe", {
+        messages: [ {
+            role: "system",
+            content: AgenticaDefaultPrompt.write(ctx.config)
+        }, ...histories.map(decodePrompt).flat(), {
+            role: "system",
+            content: ctx.config?.systemPrompt?.describe?.(histories) ?? AgenticaSystemPrompt.DESCRIBE
+        } ]
+    });
+    const describeContext = [];
+    const completion = await StreamUtil.reduce(completionStream, (async (accPromise, chunk) => {
+        const acc = await accPromise;
+        const registerContext = choices => {
+            for (const choice of choices) {
+                if (choice.finish_reason != null) {
+                    describeContext[choice.index].mpsc.close();
+                    continue;
+                }
+                if (choice.delta.content == null) {
+                    continue;
+                }
+                if (describeContext[choice.index] != null) {
+                    describeContext[choice.index].content += choice.delta.content;
+                    describeContext[choice.index].mpsc.produce(choice.delta.content);
+                    continue;
+                }
+                const mpsc = new MPSC;
+                describeContext[choice.index] = {
+                    content: choice.delta.content,
+                    mpsc
+                };
+                mpsc.produce(choice.delta.content);
+                void ctx.dispatch(createDescribeEvent({
+                    executes: histories,
+                    stream: mpsc.consumer,
+                    done: () => mpsc.done(),
+                    get: () => describeContext[choice.index]?.content ?? "",
+                    join: async () => {
+                        await mpsc.waitClosed();
+                        return describeContext[choice.index].content;
+                    }
+                }));
+            }
+        };
+        if (acc.object === "chat.completion.chunk") {
+            registerContext([ acc, chunk ].flatMap((v => v.choices)));
+            return ChatGptCompletionMessageUtil.merge([ acc, chunk ]);
+        }
+        registerContext(chunk.choices);
+        return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
+    }));
+    if (completion == null) {
+        throw new Error("No completion received");
+    }
+    const descriptions = completion.choices.map((choice => choice.message.role === "assistant" ? choice.message.content : null)).filter((str => str !== null)).map((content => createDescribePrompt({
+        executes: histories,
+        text: content
+    })));
+    return descriptions;
 }
 
+const ChatGptDescribeFunctionAgent = {
+    execute: describe
+};
+
+var AgenticaConstant;
+
+(function(AgenticaConstant) {
+    AgenticaConstant.RETRY = 3;
+    AgenticaConstant.ELITICISM = true;
+})(AgenticaConstant || (AgenticaConstant = {}));
+
 async function cancelFunction(ctx, reference) {
     const index = ctx.stack.findIndex((item => item.operation.name === reference.name));
     if (index === -1) {
@@ -1161,34 +1484,167 @@ async function cancelFunction(ctx, reference) {
     return item;
 }
 
-async function step$1(ctx, operations, retry, failures) {
-    const completionStream = await ctx.request("cancel", {
-        messages: [ {
-            role: "system",
-            content: AgenticaDefaultPrompt.write(ctx.config)
-        }, {
-            role: "assistant",
-            tool_calls: [ {
-                type: "function",
-                id: "getApiFunctions",
-                function: {
-                    name: "getApiFunctions",
-                    arguments: JSON.stringify({})
+const CONTAINER$1 = {
+    functions: [ {
+        name: "cancelFunctions",
+        parameters: {
+            description: " Properties of the function\n\n------------------------------\n\nCurrent Type: {@link __IChatFunctionReference.IProps}",
+            type: "object",
+            properties: {
+                functions: {
+                    title: "List of target functions",
+                    description: "List of target functions.",
+                    type: "array",
+                    items: {
+                        description: "Current Type: {@link ___IChatFunctionReference}",
+                        type: "object",
+                        properties: {
+                            reason: {
+                                title: "The reason of the function selection",
+                                description: "The reason of the function selection.\n\nJust write the reason why you've determined to select this function.",
+                                type: "string"
+                            },
+                            name: {
+                                title: "Name of the target function to call",
+                                description: "Name of the target function to call.",
+                                type: "string"
+                            }
+                        },
+                        required: [ "reason", "name" ]
+                    }
                 }
-            } ]
-        }, {
-            role: "tool",
-            tool_call_id: "getApiFunctions",
-            content: JSON.stringify(operations.map((op => ({
-                name: op.name,
-                description: op.function.description,
-                ...op.protocol === "http" ? {
+            },
+            required: [ "functions" ],
+            additionalProperties: false,
+            $defs: {}
+        },
+        description: "Cancel a function from the candidate list to call.\n\nIf you A.I. agent has understood that the user wants to cancel\nsome candidate functions to call from the conversation, please cancel\nthem through this function.\n\nAlso, when you A.I. find a function that has been selected by the candidate\npooling, cancel the function by calling this function. For reference, the\ncandidate pooling means that user wants only one function to call, but you A.I.\nagent selects multiple candidate functions because the A.I. agent can't specify\nonly one thing due to lack of specificity or homogeneity of candidate functions.\n\nAdditionally, if you A.I. agent wants to cancel same function multiply, you can\ndo it by assigning the same function name multiply in the `functions` property.",
+        validate: (() => {
+            const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
+            const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
+            const _vo0 = (input, _path, _exceptionable = true) => [ (Array.isArray(input.functions) || _report(_exceptionable, {
+                path: _path + ".functions",
+                expected: "Array<___IChatFunctionReference>",
+                value: input.functions
+            })) && input.functions.map(((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                path: _path + ".functions[" + _index2 + "]",
+                expected: "___IChatFunctionReference",
+                value: elem
+            })) && _vo1(elem, _path + ".functions[" + _index2 + "]", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".functions[" + _index2 + "]",
+                expected: "___IChatFunctionReference",
+                value: elem
+            }))).every((flag => flag)) || _report(_exceptionable, {
+                path: _path + ".functions",
+                expected: "Array<___IChatFunctionReference>",
+                value: input.functions
+            }) ].every((flag => flag));
+            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.reason || _report(_exceptionable, {
+                path: _path + ".reason",
+                expected: "string",
+                value: input.reason
+            }), "string" === typeof input.name || _report(_exceptionable, {
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }) ].every((flag => flag));
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let errors;
+            let _report;
+            return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "__IChatFunctionReference.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "__IChatFunctionReference.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            };
+        })()
+    } ]
+};
+
+async function cancel(ctx) {
+    if (ctx.operations.divided === undefined) {
+        return step$1(ctx, ctx.operations.array, 0);
+    }
+    const stacks = ctx.operations.divided.map((() => []));
+    const events = [];
+    const prompts = await Promise.all(ctx.operations.divided.map((async (operations, i) => step$1({
+        ...ctx,
+        stack: stacks[i],
+        dispatch: async e => {
+            events.push(e);
+        }
+    }, operations, 0))));
+    if (stacks.every((s => s.length === 0))) {
+        return prompts[0];
+    } else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) {
+        return step$1(ctx, stacks.flat().map((s => ctx.operations.group.get(s.operation.controller.name).get(s.operation.function.name))), 0);
+    }
+    const collection = createCancelPrompt({
+        id: v4(),
+        selections: []
+    });
+    for (const e of events) {
+        if (e.type === "select") {
+            collection.selections.push(e.selection);
+            await cancelFunction(ctx, {
+                name: e.selection.operation.name,
+                reason: e.selection.reason
+            });
+        }
+    }
+    return [ collection ];
+}
+
+async function step$1(ctx, operations, retry, failures) {
+    const completionStream = await ctx.request("cancel", {
+        messages: [ {
+            role: "system",
+            content: AgenticaDefaultPrompt.write(ctx.config)
+        }, {
+            role: "assistant",
+            tool_calls: [ {
+                type: "function",
+                id: "getApiFunctions",
+                function: {
+                    name: "getApiFunctions",
+                    arguments: JSON.stringify({})
+                }
+            } ]
+        }, {
+            role: "tool",
+            tool_call_id: "getApiFunctions",
+            content: JSON.stringify(operations.map((op => ({
+                name: op.name,
+                description: op.function.description,
+                ...op.protocol === "http" ? {
                     method: op.function.method,
                     path: op.function.path,
                     tags: op.function.tags
                 } : {}
             }))))
-        }, ...ctx.histories.map(ChatGptHistoryDecoder.decode).flat(), {
+        }, ...ctx.histories.map(decodePrompt).flat(), {
             role: "user",
             content: ctx.prompt.text
         }, {
@@ -1352,17 +1808,12 @@ function emendMessages$1(failures) {
     } ])).flat();
 }
 
-const ChatGptCancelFunctionAgent = {
-    execute: execute$4,
-    cancelFunction
-};
-
-async function execute$3(ctx) {
+async function call(ctx) {
     const completionStream = await ctx.request("call", {
         messages: [ {
             role: "system",
             content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...ctx.histories.map(ChatGptHistoryDecoder.decode).flat(), {
+        }, ...ctx.histories.map(decodePrompt).flat(), {
             role: "user",
             content: ctx.prompt.text
         }, {
@@ -1416,7 +1867,7 @@ async function execute$3(ctx) {
                         arguments: execute.arguments,
                         value: execute.value
                     }));
-                    await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
+                    await cancelFunction(ctx, {
                         name: call.operation.name,
                         reason: "completed"
                     });
@@ -1571,7 +2022,7 @@ async function correct(ctx, call, retry, error) {
         messages: [ {
             role: "system",
             content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...ctx.histories.map(ChatGptHistoryDecoder.decode).flat(), {
+        }, ...ctx.histories.map(decodePrompt).flat(), {
             role: "user",
             content: ctx.prompt.text
         }, {
@@ -1642,183 +2093,6 @@ function isObject($defs, schema) {
     return ChatGptTypeChecker.isObject(schema) || ChatGptTypeChecker.isReference(schema) && isObject($defs, $defs[schema.$ref.split("/").at(-1)]) || ChatGptTypeChecker.isAnyOf(schema) && schema.anyOf.every((schema => isObject($defs, schema)));
 }
 
-const ChatGptCallFunctionAgent = {
-    execute: execute$3
-};
-
-class AsyncQueue {
-    constructor() {
-        this.queue = [];
-        this.resolvers = [];
-        this.closeResolvers = [];
-        this.emptyResolvers = [];
-        this.closed = false;
-    }
-    enqueue(item) {
-        this.queue.push(item);
-        if (this.resolvers.length > 0) {
-            this.resolvers.shift()?.({
-                value: this.queue.shift(),
-                done: false
-            });
-        }
-    }
-    async dequeue() {
-        if (this.queue.length > 0) {
-            return {
-                value: this.queue.shift(),
-                done: false
-            };
-        }
-        if (this.closed) {
-            if (this.emptyResolvers.length > 0) {
-                this.emptyResolvers.forEach((resolve => resolve()));
-                this.emptyResolvers = [];
-            }
-            return {
-                value: undefined,
-                done: true
-            };
-        }
-        return new Promise((resolve => this.resolvers.push(resolve)));
-    }
-    isEmpty() {
-        return this.queue.length === 0;
-    }
-    isClosed() {
-        return this.closed;
-    }
-    done() {
-        return this.isClosed() && this.isEmpty();
-    }
-    close() {
-        this.closed = true;
-        while (this.resolvers.length > 0) {
-            this.resolvers.shift()?.({
-                value: undefined,
-                done: true
-            });
-        }
-        this.closeResolvers.forEach((resolve => resolve()));
-    }
-    async waitUntilEmpty() {
-        if (this.isEmpty()) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve => {
-            this.emptyResolvers.push(resolve);
-        }));
-    }
-    async waitClosed() {
-        if (this.isClosed()) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve => {
-            this.closeResolvers.push(resolve);
-        }));
-    }
-}
-
-class MPSC {
-    constructor() {
-        this.queue = new AsyncQueue;
-        this.consumer = new ReadableStream({
-            pull: async controller => {
-                const {value, done} = await this.queue.dequeue();
-                if (done === true) {
-                    controller.close();
-                    return;
-                }
-                controller.enqueue(value);
-            }
-        });
-    }
-    produce(chunk) {
-        this.queue.enqueue(chunk);
-    }
-    close() {
-        this.queue.close();
-    }
-    done() {
-        return this.queue.done();
-    }
-    async waitClosed() {
-        await this.queue.waitClosed();
-    }
-    async waitUntilEmpty() {
-        await this.queue.waitUntilEmpty();
-    }
-}
-
-async function execute$2(ctx, histories) {
-    if (histories.length === 0) {
-        return [];
-    }
-    const completionStream = await ctx.request("describe", {
-        messages: [ {
-            role: "system",
-            content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...histories.map(ChatGptHistoryDecoder.decode).flat(), {
-            role: "system",
-            content: ctx.config?.systemPrompt?.describe?.(histories) ?? AgenticaSystemPrompt.DESCRIBE
-        } ]
-    });
-    const describeContext = [];
-    const completion = await StreamUtil.reduce(completionStream, (async (accPromise, chunk) => {
-        const acc = await accPromise;
-        const registerContext = choices => {
-            for (const choice of choices) {
-                if (choice.finish_reason != null) {
-                    describeContext[choice.index].mpsc.close();
-                    continue;
-                }
-                if (choice.delta.content == null) {
-                    continue;
-                }
-                if (describeContext[choice.index] != null) {
-                    describeContext[choice.index].content += choice.delta.content;
-                    describeContext[choice.index].mpsc.produce(choice.delta.content);
-                    continue;
-                }
-                const mpsc = new MPSC;
-                describeContext[choice.index] = {
-                    content: choice.delta.content,
-                    mpsc
-                };
-                mpsc.produce(choice.delta.content);
-                void ctx.dispatch(createDescribeEvent({
-                    executes: histories,
-                    stream: mpsc.consumer,
-                    done: () => mpsc.done(),
-                    get: () => describeContext[choice.index]?.content ?? "",
-                    join: async () => {
-                        await mpsc.waitClosed();
-                        return describeContext[choice.index].content;
-                    }
-                }));
-            }
-        };
-        if (acc.object === "chat.completion.chunk") {
-            registerContext([ acc, chunk ].flatMap((v => v.choices)));
-            return ChatGptCompletionMessageUtil.merge([ acc, chunk ]);
-        }
-        registerContext(chunk.choices);
-        return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
-    }));
-    if (completion == null) {
-        throw new Error("No completion received");
-    }
-    const descriptions = completion.choices.map((choice => choice.message.role === "assistant" ? choice.message.content : null)).filter((str => str !== null)).map((content => createDescribePrompt({
-        executes: histories,
-        text: content
-    })));
-    return descriptions;
-}
-
-const ChatGptDescribeFunctionAgent = {
-    execute: execute$2
-};
-
 const FUNCTION = {
     functions: [ {
         name: "getApiFunctions",
@@ -3457,12 +3731,12 @@ const FUNCTION = {
     } ]
 }.functions[0];
 
-async function execute$1(ctx) {
+async function initialize(ctx) {
     const completionStream = await ctx.request("initialize", {
         messages: [ {
             role: "system",
             content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...ctx.histories.map(ChatGptHistoryDecoder.decode).flat(), {
+        }, ...ctx.histories.map(decodePrompt).flat(), {
             role: "user",
             content: ctx.prompt.text
         }, {
@@ -3540,9 +3814,21 @@ async function execute$1(ctx) {
     return prompts;
 }
 
-const ChatGptInitializeFunctionAgent = {
-    execute: execute$1
-};
+async function selectFunction(ctx, reference) {
+    const operation = ctx.operations.flat.get(reference.name);
+    if (operation === undefined) {
+        return null;
+    }
+    const selection = createOperationSelection({
+        operation,
+        reason: reference.reason
+    });
+    ctx.stack.push(selection);
+    void ctx.dispatch(createSelectEvent({
+        selection
+    }));
+    return operation;
+}
 
 const CONTAINER = {
     functions: [ {
@@ -3643,7 +3929,7 @@ const CONTAINER = {
     } ]
 };
 
-async function execute(ctx) {
+async function select(ctx) {
     if (ctx.operations.divided === undefined) {
         return step(ctx, ctx.operations.array, 0);
     }
@@ -3704,7 +3990,7 @@ async function step(ctx, operations, retry, failures) {
                     tags: op.function.tags
                 } : {}
             }))))
-        }, ...ctx.histories.map(ChatGptHistoryDecoder.decode).flat(), {
+        }, ...ctx.histories.map(decodePrompt).flat(), {
             role: "user",
             content: ctx.prompt.text
         }, {
@@ -3773,467 +4059,158 @@ async function step(ctx, operations, retry, failures) {
                                 expected: "__IChatFunctionReference.IProps",
                                 value: input
                             })) && _vo0(input, _path + "", true) || _report(true, {
-                                path: _path + "",
-                                expected: "__IChatFunctionReference.IProps",
-                                value: input
-                            }))(input, "$input", true);
-                            const success = 0 === errors.length;
-                            return success ? {
-                                success,
-                                data: input
-                            } : {
-                                success,
-                                errors,
-                                data: input
-                            };
-                        }
-                        return {
-                            success: true,
-                            data: input
-                        };
-                    };
-                })()(input);
-                if (validation.success === false) {
-                    failures.push({
-                        id: tc.id,
-                        name: tc.function.name,
-                        validation
-                    });
-                }
-            }
-        }
-        if (failures.length > 0) {
-            return step(ctx, operations, retry, failures);
-        }
-    }
-    const prompts = [];
-    for (const choice of completion.choices) {
-        if (choice.message.tool_calls != null) {
-            for (const tc of choice.message.tool_calls) {
-                if (tc.type !== "function") {
-                    continue;
-                }
-                if (tc.function.name !== "selectFunctions") {
-                    continue;
-                }
-                const input = (() => {
-                    const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
-                    const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
-                    const __is = input => "object" === typeof input && null !== input && _io0(input);
-                    return input => {
-                        input = JSON.parse(input);
-                        return __is(input) ? input : null;
-                    };
-                })()(tc.function.arguments);
-                if (input === null) {
-                    continue;
-                }
-                const collection = createSelectPrompt({
-                    id: tc.id,
-                    selections: []
-                });
-                for (const reference of input.functions) {
-                    const operation = await selectFunction(ctx, reference);
-                    if (operation === null) {
-                        continue;
-                    }
-                    collection.selections.push(createOperationSelection({
-                        operation,
-                        reason: reference.reason
-                    }));
-                }
-                if (collection.selections.length !== 0) {
-                    prompts.push(collection);
-                }
-            }
-        }
-        if (choice.message.role === "assistant" && choice.message.content != null) {
-            const text = createTextPrompt({
-                role: "assistant",
-                text: choice.message.content
-            });
-            prompts.push(text);
-            await ctx.dispatch(createTextEvent({
-                role: "assistant",
-                stream: StreamUtil.to(text.text),
-                join: async () => Promise.resolve(text.text),
-                done: () => true,
-                get: () => text.text
-            }));
-        }
-    }
-    return prompts;
-}
-
-async function selectFunction(ctx, reference) {
-    const operation = ctx.operations.flat.get(reference.name);
-    if (operation === undefined) {
-        return null;
-    }
-    const selection = createOperationSelection({
-        operation,
-        reason: reference.reason
-    });
-    ctx.stack.push(selection);
-    void ctx.dispatch(createSelectEvent({
-        selection
-    }));
-    return operation;
-}
-
-function emendMessages(failures) {
-    return failures.map((f => [ {
-        role: "assistant",
-        tool_calls: [ {
-            type: "function",
-            id: f.id,
-            function: {
-                name: f.name,
-                arguments: JSON.stringify(f.validation.data)
-            }
-        } ]
-    }, {
-        role: "tool",
-        content: JSON.stringify(f.validation.errors),
-        tool_call_id: f.id
-    }, {
-        role: "system",
-        content: [ "You A.I. assistant has composed wrong typed arguments.", "", "Correct it at the next function calling." ].join("\n")
-    } ])).flat();
-}
-
-const ChatGptSelectFunctionAgent = {
-    execute,
-    selectFunction,
-    emendMessages
-};
-
-const ChatGptAgent = {
-    execute: executor => async ctx => {
-        const histories = [];
-        if (ctx.ready() === false) {
-            if (executor?.initialize === null) {
-                await ctx.initialize();
-            } else {
-                histories.push(...await (executor?.initialize ?? ChatGptInitializeFunctionAgent.execute)(ctx));
-                if (ctx.ready() === false) {
-                    return histories;
-                }
-            }
-        }
-        if (ctx.stack.length !== 0) {
-            histories.push(...await (executor?.cancel ?? ChatGptCancelFunctionAgent.execute)(ctx));
-        }
-        histories.push(...await (executor?.select ?? ChatGptSelectFunctionAgent.execute)(ctx));
-        if (ctx.stack.length === 0) {
-            return histories;
-        }
-        while (true) {
-            const prompts = await (executor?.call ?? ChatGptCallFunctionAgent.execute)(ctx);
-            histories.push(...prompts);
-            const executes = prompts.filter((prompt => prompt.type === "execute"));
-            for (const e of executes) {
-                await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
-                    reason: "completed",
-                    name: e.operation.name
-                });
-            }
-            histories.push(...await (executor?.describe ?? ChatGptDescribeFunctionAgent.execute)(ctx, executes));
-            if (executes.length === 0 || ctx.stack.length === 0) {
-                break;
-            }
-        }
-        return histories;
-    }
-};
-
-class AgenticaTokenUsage {
-    constructor(props) {
-        if (props === undefined) {
-            const zero = AgenticaTokenUsage.zero();
-            this.aggregate = zero.aggregate;
-            this.initialize = zero.initialize;
-            this.select = zero.select;
-            this.cancel = zero.cancel;
-            this.call = zero.call;
-            this.describe = zero.describe;
-        } else {
-            this.aggregate = props.aggregate;
-            this.initialize = props.initialize;
-            this.select = props.select;
-            this.cancel = props.cancel;
-            this.call = props.call;
-            this.describe = props.describe;
-        }
-    }
-    increment(y) {
-        const increment = (x, y) => {
-            x.total += y.total;
-            x.input.total += y.input.total;
-            x.input.cached += y.input.cached;
-            x.output.total += y.output.total;
-            x.output.reasoning += y.output.reasoning;
-            x.output.accepted_prediction += y.output.accepted_prediction;
-            x.output.rejected_prediction += y.output.rejected_prediction;
-        };
-        increment(this.aggregate, y.aggregate);
-        increment(this.initialize, y.initialize);
-        increment(this.select, y.select);
-        increment(this.cancel, y.cancel);
-        increment(this.call, y.call);
-        increment(this.describe, y.describe);
-    }
-    toJSON() {
-        return (() => {
-            const _co0 = input => ({
-                aggregate: _co1(input.aggregate),
-                initialize: _co1(input.initialize),
-                select: _co1(input.select),
-                cancel: _co1(input.cancel),
-                call: _co1(input.call),
-                describe: _co1(input.describe)
-            });
-            const _co1 = input => ({
-                total: input.total,
-                input: _co2(input.input),
-                output: _co3(input.output)
-            });
-            const _co2 = input => ({
-                total: input.total,
-                cached: input.cached
-            });
-            const _co3 = input => ({
-                total: input.total,
-                reasoning: input.reasoning,
-                accepted_prediction: input.accepted_prediction,
-                rejected_prediction: input.rejected_prediction
-            });
-            return input => _co0(input);
-        })()(this);
-    }
-    static zero() {
-        const component = () => ({
-            total: 0,
-            input: {
-                total: 0,
-                cached: 0
-            },
-            output: {
-                total: 0,
-                reasoning: 0,
-                accepted_prediction: 0,
-                rejected_prediction: 0
-            }
-        });
-        return new AgenticaTokenUsage({
-            aggregate: component(),
-            initialize: component(),
-            select: component(),
-            cancel: component(),
-            call: component(),
-            describe: component()
-        });
-    }
-    static plus(x, y) {
-        const z = new AgenticaTokenUsage(x);
-        z.increment(y.toJSON());
-        return z;
-    }
-}
-
-function aggregate(props) {
-    const component = props.usage[props.kind];
-    component.total += props.completionUsage.total_tokens;
-    component.input.total += props.completionUsage.prompt_tokens;
-    component.input.total += props.completionUsage.prompt_tokens_details?.audio_tokens ?? 0;
-    component.input.cached += props.completionUsage.prompt_tokens_details?.cached_tokens ?? 0;
-    component.output.total += props.completionUsage.completion_tokens;
-    component.output.accepted_prediction += props.completionUsage.completion_tokens_details?.accepted_prediction_tokens ?? 0;
-    component.output.reasoning += props.completionUsage.completion_tokens_details?.reasoning_tokens ?? 0;
-    component.output.rejected_prediction += props.completionUsage.completion_tokens_details?.rejected_prediction_tokens ?? 0;
-    const sum = getter => Object.entries(props.usage).filter((([key]) => key !== "aggregate")).map((([, comp]) => getter(comp))).reduce(((a, b) => a + b), 0);
-    const aggregate = props.usage.aggregate;
-    aggregate.total = sum((comp => comp.total));
-    aggregate.input.total = sum((comp => comp.input.total));
-    aggregate.input.cached = sum((comp => comp.input.cached));
-    aggregate.output.total = sum((comp => comp.output.total));
-    aggregate.output.reasoning = sum((comp => comp.output.reasoning));
-    aggregate.output.accepted_prediction = sum((comp => comp.output.accepted_prediction));
-    aggregate.output.rejected_prediction = sum((comp => comp.output.rejected_prediction));
-}
-
-const AgenticaTokenUsageAggregator = {
-    aggregate
-};
-
-function __map_take(dict, key, generator) {
-    const oldbie = dict.get(key);
-    if (oldbie !== undefined) {
-        return oldbie;
-    }
-    const value = generator();
-    dict.set(key, value);
-    return value;
-}
-
-function compose(props) {
-    const unique = props.controllers.length === 1 || (() => {
-        const names = props.controllers.map((controller => controller.application.functions.map((func => func.name)))).flat();
-        return new Set(names).size === names.length;
-    })();
-    const naming = (func, ci) => unique ? func : `_${ci}_${func}`;
-    const array = props.controllers.map(((controller, ci) => controller.protocol === "http" ? controller.application.functions.map((func => ({
-        protocol: "http",
-        controller,
-        function: func,
-        name: naming(func.name, ci),
-        toJSON: () => ({
-            protocol: "http",
-            controller: controller.name,
-            function: func.name,
-            name: naming(func.name, ci)
-        })
-    }))) : controller.application.functions.map((func => ({
-        protocol: "class",
-        controller,
-        function: func,
-        name: naming(func.name, ci),
-        toJSON: () => ({
-            protocol: "class",
-            controller: controller.name,
-            function: func.name,
-            name: naming(func.name, ci)
-        })
-    }))))).flat();
-    const divided = props.config?.capacity !== undefined && array.length > props.config.capacity ? divide({
-        array,
-        capacity: props.config.capacity
-    }) : undefined;
-    const flat = new Map;
-    const group = new Map;
-    for (const item of array) {
-        flat.set(item.name, item);
-        __map_take(group, item.controller.name, (() => new Map)).set(item.name, item);
+                                path: _path + "",
+                                expected: "__IChatFunctionReference.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
+                            data: input
+                        };
+                    };
+                })()(input);
+                if (validation.success === false) {
+                    failures.push({
+                        id: tc.id,
+                        name: tc.function.name,
+                        validation
+                    });
+                }
+            }
+        }
+        if (failures.length > 0) {
+            return step(ctx, operations, retry, failures);
+        }
     }
-    return {
-        array,
-        divided,
-        flat,
-        group
-    };
-}
-
-function divide(props) {
-    const size = Math.ceil(props.array.length / props.capacity);
-    const capacity = Math.ceil(props.array.length / size);
-    const replica = props.array.slice();
-    return Array.from({
-        length: size
-    }, (() => replica.splice(0, capacity)));
-}
-
-const AgenticaOperationComposer = {
-    compose
-};
-
-function transform(props) {
-    if (props.prompt.type === "text") {
-        return transformText({
-            prompt: props.prompt
-        });
-    } else if (props.prompt.type === "select") {
-        return transformSelect({
-            operations: props.operations,
-            prompt: props.prompt
-        });
-    } else if (props.prompt.type === "cancel") {
-        return transformCancel({
-            operations: props.operations,
-            prompt: props.prompt
-        });
-    } else if (props.prompt.type === "execute") {
-        return transformExecute({
-            operations: props.operations,
-            prompt: props.prompt
-        });
-    } else if (props.prompt.type === "describe") {
-        return transformDescribe({
-            operations: props.operations,
-            prompt: props.prompt
-        });
+    const prompts = [];
+    for (const choice of completion.choices) {
+        if (choice.message.tool_calls != null) {
+            for (const tc of choice.message.tool_calls) {
+                if (tc.type !== "function") {
+                    continue;
+                }
+                if (tc.function.name !== "selectFunctions") {
+                    continue;
+                }
+                const input = (() => {
+                    const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
+                    const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    return input => {
+                        input = JSON.parse(input);
+                        return __is(input) ? input : null;
+                    };
+                })()(tc.function.arguments);
+                if (input === null) {
+                    continue;
+                }
+                const collection = createSelectPrompt({
+                    id: tc.id,
+                    selections: []
+                });
+                for (const reference of input.functions) {
+                    const operation = await selectFunction(ctx, reference);
+                    if (operation === null) {
+                        continue;
+                    }
+                    collection.selections.push(createOperationSelection({
+                        operation,
+                        reason: reference.reason
+                    }));
+                }
+                if (collection.selections.length !== 0) {
+                    prompts.push(collection);
+                }
+            }
+        }
+        if (choice.message.role === "assistant" && choice.message.content != null) {
+            const text = createTextPrompt({
+                role: "assistant",
+                text: choice.message.content
+            });
+            prompts.push(text);
+            await ctx.dispatch(createTextEvent({
+                role: "assistant",
+                stream: StreamUtil.to(text.text),
+                join: async () => Promise.resolve(text.text),
+                done: () => true,
+                get: () => text.text
+            }));
+        }
     }
-    throw new Error("Invalid prompt type.");
-}
-
-function transformText(props) {
-    return createTextPrompt(props.prompt);
-}
-
-function transformSelect(props) {
-    return createSelectPrompt({
-        id: props.prompt.id,
-        selections: props.prompt.selections.map((select => createOperationSelection({
-            operation: findOperation({
-                operations: props.operations,
-                input: select.operation
-            }),
-            reason: select.reason
-        })))
-    });
-}
-
-function transformCancel(props) {
-    return createCancelPrompt({
-        id: props.prompt.id,
-        selections: props.prompt.selections.map((select => createOperationSelection({
-            operation: findOperation({
-                operations: props.operations,
-                input: select.operation
-            }),
-            reason: select.reason
-        })))
-    });
-}
-
-function transformExecute(props) {
-    return createExecutePrompt({
-        id: props.prompt.id,
-        operation: findOperation({
-            operations: props.operations,
-            input: props.prompt.operation
-        }),
-        arguments: props.prompt.arguments,
-        value: props.prompt.value
-    });
+    return prompts;
 }
 
-function transformDescribe(props) {
-    return createDescribePrompt({
-        text: props.prompt.text,
-        executes: props.prompt.executes.map((next => transformExecute({
-            operations: props.operations,
-            prompt: next
-        })))
-    });
+function emendMessages(failures) {
+    return failures.map((f => [ {
+        role: "assistant",
+        tool_calls: [ {
+            type: "function",
+            id: f.id,
+            function: {
+                name: f.name,
+                arguments: JSON.stringify(f.validation.data)
+            }
+        } ]
+    }, {
+        role: "tool",
+        content: JSON.stringify(f.validation.errors),
+        tool_call_id: f.id
+    }, {
+        role: "system",
+        content: [ "You A.I. assistant has composed wrong typed arguments.", "", "Correct it at the next function calling." ].join("\n")
+    } ])).flat();
 }
 
-function findOperation(props) {
-    const found = props.operations.get(props.input.controller)?.get(props.input.function);
-    if (found === undefined) {
-        throw new Error(`No operation found: (controller: ${props.input.controller}, function: ${props.input.function})`);
-    }
-    return found;
+function execute(executor) {
+    return async ctx => {
+        const histories = [];
+        if (ctx.ready() === false) {
+            if (executor?.initialize === null) {
+                await ctx.initialize();
+            } else {
+                histories.push(...await (executor?.initialize ?? initialize)(ctx));
+                if (ctx.ready() === false) {
+                    return histories;
+                }
+            }
+        }
+        if (ctx.stack.length !== 0) {
+            histories.push(...await (executor?.cancel ?? cancel)(ctx));
+        }
+        histories.push(...await (executor?.select ?? select)(ctx));
+        if (ctx.stack.length === 0) {
+            return histories;
+        }
+        while (true) {
+            const prompts = await (executor?.call ?? call)(ctx);
+            histories.push(...prompts);
+            const executes = prompts.filter((prompt => prompt.type === "execute"));
+            for (const e of executes) {
+                await cancelFunction(ctx, {
+                    reason: "completed",
+                    name: e.operation.name
+                });
+            }
+            histories.push(...await (executor?.describe ?? describe)(ctx, executes));
+            if (executes.length === 0 || ctx.stack.length === 0) {
+                break;
+            }
+        }
+        return histories;
+    };
 }
 
-const AgenticaPromptTransformer = {
-    transform,
-    transformText,
-    transformSelect,
-    transformCancel,
-    transformExecute,
-    transformDescribe
-};
-
 class Agentica {
     constructor(props) {
         this.props = props;
@@ -4249,7 +4226,7 @@ class Agentica {
         })));
         this.token_usage_ = AgenticaTokenUsage.zero();
         this.ready_ = false;
-        this.executor_ = typeof props.config?.executor === "function" ? props.config.executor : ChatGptAgent.execute(props.config?.executor ?? null);
+        this.executor_ = typeof props.config?.executor === "function" ? props.config.executor : execute(props.config?.executor ?? null);
     }
     clone() {
         return new Agentica({
@@ -4383,7 +4360,7 @@ class Agentica {
     }
 }
 
-var index$1 = Object.freeze({
+var index$2 = Object.freeze({
     __proto__: null,
     createCallEvent,
     createCancelEvent,
@@ -4400,7 +4377,8 @@ var index$1 = Object.freeze({
     createSelectPrompt,
     createTextEvent,
     createTextPrompt,
-    createValidateEvent
+    createValidateEvent,
+    decodePrompt
 });
 
 function assertHttpLlmApplication(props) {
@@ -21119,17 +21097,24 @@ function validateHttpLlmApplication(props) {
     };
 }
 
+var index$1 = Object.freeze({
+    __proto__: null,
+    ChatGptDescribeFunctionAgent,
+    call,
+    cancel,
+    describe,
+    execute,
+    initialize,
+    select
+});
+
 var index = Object.freeze({
     __proto__: null,
-    ChatGptAgent,
-    ChatGptCallFunctionAgent,
-    ChatGptCancelFunctionAgent,
+    AsyncQueue,
     ChatGptCompletionMessageUtil,
-    ChatGptDescribeFunctionAgent,
-    ChatGptHistoryDecoder,
-    ChatGptInitializeFunctionAgent,
-    ChatGptSelectFunctionAgent
+    MPSC,
+    StreamUtil
 });
 
-export { Agentica, AgenticaTokenUsage, assertHttpLlmApplication, index$1 as factory, index as orchestrate, validateHttpLlmApplication };
+export { Agentica, AgenticaTokenUsage, assertHttpLlmApplication, index$2 as factory, index$1 as orchestrate, index as utils, validateHttpLlmApplication };
 //# sourceMappingURL=index.mjs.map