@agentica/core 0.15.5 → 0.15.6

package/lib/index.mjs

@@ -1,1487 +1,1501 @@
-import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
-
 import "typia";
 
 import { v4 } from "uuid";
 
-import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
-
 import { HttpLlm, ChatGptTypeChecker, OpenApi } from "@samchon/openapi";
 
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+
 import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 
-var ByteArrayUtil;
+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(ByteArrayUtil) {
-    function toUtf8(byteArray) {
-        return (new TextDecoder).decode(byteArray);
+function __map_take(dict, key, generator) {
+    const oldbie = dict.get(key);
+    if (oldbie !== undefined) {
+        return oldbie;
     }
-    ByteArrayUtil.toUtf8 = toUtf8;
-})(ByteArrayUtil || (ByteArrayUtil = {}));
+    const value = generator();
+    dict.set(key, value);
+    return value;
+}
 
-function sumCompletionTokenDetail(x, y) {
+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 {
-        accepted_prediction_tokens: (x.accepted_prediction_tokens ?? 0) + (y.accepted_prediction_tokens ?? 0),
-        reasoning_tokens: (x.reasoning_tokens ?? 0) + (y.reasoning_tokens ?? 0),
-        rejected_prediction_tokens: (x.rejected_prediction_tokens ?? 0) + (y.rejected_prediction_tokens ?? 0)
+        array,
+        divided,
+        flat,
+        group
     };
 }
 
-function sumPromptTokenDetail(x, y) {
-    return {
-        audio_tokens: (x.audio_tokens ?? 0) + (y.audio_tokens ?? 0),
-        cached_tokens: (x.cached_tokens ?? 0) + (y.cached_tokens ?? 0)
-    };
+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)));
 }
 
-function sum(x, y) {
-    return {
-        prompt_tokens: (x.prompt_tokens ?? 0) + (y.prompt_tokens ?? 0),
-        completion_tokens: (x.completion_tokens ?? 0) + (y.completion_tokens ?? 0),
-        total_tokens: (x.total_tokens ?? 0) + (y.total_tokens ?? 0),
-        completion_tokens_details: sumCompletionTokenDetail(x.completion_tokens_details ?? {
-            accepted_prediction_tokens: 0,
-            reasoning_tokens: 0,
-            rejected_prediction_tokens: 0
-        }, y.completion_tokens_details ?? {
-            accepted_prediction_tokens: 0,
-            reasoning_tokens: 0,
-            rejected_prediction_tokens: 0
-        }),
-        prompt_tokens_details: sumPromptTokenDetail(x.prompt_tokens_details ?? {
-            audio_tokens: 0,
-            cached_tokens: 0
-        }, y.prompt_tokens_details ?? {
-            audio_tokens: 0,
-            cached_tokens: 0
-        })
-    };
+const AgenticaOperationComposer = {
+    compose
+};
+
+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 ChatGptTokenUsageAggregator = {
-    sum,
-    sumCompletionTokenDetail,
-    sumPromptTokenDetail
+const AgenticaTokenUsageAggregator = {
+    aggregate
 };
 
-function transformCompletionChunk(source) {
-    const str = source instanceof Uint8Array ? ByteArrayUtil.toUtf8(source) : source;
-    return (() => {
-        const _io0 = input => "string" === typeof input.id && (Array.isArray(input.choices) && input.choices.every((elem => "object" === typeof elem && null !== elem && _io1(elem)))) && "number" === typeof input.created && "string" === typeof input.model && "chat.completion.chunk" === input.object && (null === input.service_tier || undefined === input.service_tier || "scale" === input.service_tier || "default" === input.service_tier) && (undefined === input.system_fingerprint || "string" === typeof input.system_fingerprint) && (null === input.usage || undefined === input.usage || "object" === typeof input.usage && null !== input.usage && _io9(input.usage));
-        const _io1 = input => "object" === typeof input.delta && null !== input.delta && false === Array.isArray(input.delta) && _io2(input.delta) && (null === input.finish_reason || "function_call" === input.finish_reason || "stop" === input.finish_reason || "length" === input.finish_reason || "tool_calls" === input.finish_reason || "content_filter" === input.finish_reason) && "number" === typeof input.index && (null === input.logprobs || undefined === input.logprobs || "object" === typeof input.logprobs && null !== input.logprobs && _io6(input.logprobs));
-        const _io2 = input => (null === input.content || undefined === input.content || "string" === typeof input.content) && (undefined === input.function_call || "object" === typeof input.function_call && null !== input.function_call && false === Array.isArray(input.function_call) && _io3(input.function_call)) && (null === input.refusal || undefined === input.refusal || "string" === typeof input.refusal) && (undefined === input.role || "assistant" === input.role || "user" === input.role || "developer" === input.role || "system" === input.role || "tool" === input.role) && (undefined === input.tool_calls || Array.isArray(input.tool_calls) && input.tool_calls.every((elem => "object" === typeof elem && null !== elem && _io4(elem))));
-        const _io3 = input => (undefined === input.arguments || "string" === typeof input.arguments) && (undefined === input.name || "string" === typeof input.name);
-        const _io4 = input => "number" === typeof input.index && (undefined === input.id || "string" === typeof input.id) && (undefined === input["function"] || "object" === typeof input["function"] && null !== input["function"] && false === Array.isArray(input["function"]) && _io5(input["function"])) && (undefined === input.type || "function" === input.type);
-        const _io5 = input => (undefined === input.arguments || "string" === typeof input.arguments) && (undefined === input.name || "string" === typeof input.name);
-        const _io6 = input => (null === input.content || Array.isArray(input.content) && input.content.every((elem => "object" === typeof elem && null !== elem && _io7(elem)))) && (null === input.refusal || Array.isArray(input.refusal) && input.refusal.every((elem => "object" === typeof elem && null !== elem && _io7(elem))));
-        const _io7 = input => "string" === typeof input.token && (null === input.bytes || Array.isArray(input.bytes) && input.bytes.every((elem => "number" === typeof elem))) && "number" === typeof input.logprob && (Array.isArray(input.top_logprobs) && input.top_logprobs.every((elem => "object" === typeof elem && null !== elem && _io8(elem))));
-        const _io8 = input => "string" === typeof input.token && (null === input.bytes || Array.isArray(input.bytes) && input.bytes.every((elem => "number" === typeof elem))) && "number" === typeof input.logprob;
-        const _io9 = input => "number" === typeof input.completion_tokens && "number" === typeof input.prompt_tokens && "number" === typeof input.total_tokens && (undefined === input.completion_tokens_details || "object" === typeof input.completion_tokens_details && null !== input.completion_tokens_details && false === Array.isArray(input.completion_tokens_details) && _io10(input.completion_tokens_details)) && (undefined === input.prompt_tokens_details || "object" === typeof input.prompt_tokens_details && null !== input.prompt_tokens_details && false === Array.isArray(input.prompt_tokens_details) && _io11(input.prompt_tokens_details));
-        const _io10 = input => (undefined === input.accepted_prediction_tokens || "number" === typeof input.accepted_prediction_tokens) && (undefined === input.audio_tokens || "number" === typeof input.audio_tokens) && (undefined === input.reasoning_tokens || "number" === typeof input.reasoning_tokens) && (undefined === input.rejected_prediction_tokens || "number" === typeof input.rejected_prediction_tokens);
-        const _io11 = input => (undefined === input.audio_tokens || "number" === typeof input.audio_tokens) && (undefined === input.cached_tokens || "number" === typeof input.cached_tokens);
-        const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".id",
-            expected: "string",
-            value: input.id
-        }, _errorFactory)) && ((Array.isArray(input.choices) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".choices",
-            expected: "Array<ChatCompletionChunk.Choice>",
-            value: input.choices
-        }, _errorFactory)) && input.choices.every(((elem, _index8) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".choices[" + _index8 + "]",
-            expected: "ChatCompletionChunk.Choice",
-            value: elem
-        }, _errorFactory)) && _ao1(elem, _path + ".choices[" + _index8 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".choices[" + _index8 + "]",
-            expected: "ChatCompletionChunk.Choice",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".choices",
-            expected: "Array<ChatCompletionChunk.Choice>",
-            value: input.choices
-        }, _errorFactory)) && ("number" === typeof input.created || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".created",
-            expected: "number",
-            value: input.created
-        }, _errorFactory)) && ("string" === typeof input.model || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".model",
-            expected: "string",
-            value: input.model
-        }, _errorFactory)) && ("chat.completion.chunk" === input.object || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".object",
-            expected: '"chat.completion.chunk"',
-            value: input.object
-        }, _errorFactory)) && (null === input.service_tier || undefined === input.service_tier || "scale" === input.service_tier || "default" === input.service_tier || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".service_tier",
-            expected: '("default" | "scale" | null | undefined)',
-            value: input.service_tier
-        }, _errorFactory)) && (undefined === input.system_fingerprint || "string" === typeof input.system_fingerprint || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".system_fingerprint",
-            expected: "(string | undefined)",
-            value: input.system_fingerprint
-        }, _errorFactory)) && (null === input.usage || undefined === input.usage || ("object" === typeof input.usage && null !== input.usage || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".usage",
-            expected: "(CompletionUsage | null | undefined)",
-            value: input.usage
-        }, _errorFactory)) && _ao9(input.usage, _path + ".usage", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".usage",
-            expected: "(CompletionUsage | null | undefined)",
-            value: input.usage
-        }, _errorFactory));
-        const _ao1 = (input, _path, _exceptionable = true) => (("object" === typeof input.delta && null !== input.delta && false === Array.isArray(input.delta) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".delta",
-            expected: "ChatCompletionChunk.Choice.Delta",
-            value: input.delta
-        }, _errorFactory)) && _ao2(input.delta, _path + ".delta", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".delta",
-            expected: "ChatCompletionChunk.Choice.Delta",
-            value: input.delta
-        }, _errorFactory)) && (null === input.finish_reason || "function_call" === input.finish_reason || "stop" === input.finish_reason || "length" === input.finish_reason || "tool_calls" === input.finish_reason || "content_filter" === input.finish_reason || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".finish_reason",
-            expected: '("content_filter" | "function_call" | "length" | "stop" | "tool_calls" | null)',
-            value: input.finish_reason
-        }, _errorFactory)) && ("number" === typeof input.index || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".index",
-            expected: "number",
-            value: input.index
-        }, _errorFactory)) && (null === input.logprobs || undefined === input.logprobs || ("object" === typeof input.logprobs && null !== input.logprobs || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".logprobs",
-            expected: "(ChatCompletionChunk.Choice.Logprobs | null | undefined)",
-            value: input.logprobs
-        }, _errorFactory)) && _ao6(input.logprobs, _path + ".logprobs", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".logprobs",
-            expected: "(ChatCompletionChunk.Choice.Logprobs | null | undefined)",
-            value: input.logprobs
-        }, _errorFactory));
-        const _ao2 = (input, _path, _exceptionable = true) => (null === input.content || undefined === input.content || "string" === typeof input.content || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".content",
-            expected: "(null | string | undefined)",
-            value: input.content
-        }, _errorFactory)) && (undefined === input.function_call || ("object" === typeof input.function_call && null !== input.function_call && false === Array.isArray(input.function_call) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".function_call",
-            expected: "(ChatCompletionChunk.Choice.Delta.FunctionCall | undefined)",
-            value: input.function_call
-        }, _errorFactory)) && _ao3(input.function_call, _path + ".function_call", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".function_call",
-            expected: "(ChatCompletionChunk.Choice.Delta.FunctionCall | undefined)",
-            value: input.function_call
-        }, _errorFactory)) && (null === input.refusal || undefined === input.refusal || "string" === typeof input.refusal || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".refusal",
-            expected: "(null | string | undefined)",
-            value: input.refusal
-        }, _errorFactory)) && (undefined === input.role || "assistant" === input.role || "user" === input.role || "developer" === input.role || "system" === input.role || "tool" === input.role || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".role",
-            expected: '("assistant" | "developer" | "system" | "tool" | "user" | undefined)',
-            value: input.role
-        }, _errorFactory)) && (undefined === input.tool_calls || (Array.isArray(input.tool_calls) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".tool_calls",
-            expected: "(Array<ChatCompletionChunk.Choice.Delta.ToolCall> | undefined)",
-            value: input.tool_calls
-        }, _errorFactory)) && input.tool_calls.every(((elem, _index9) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".tool_calls[" + _index9 + "]",
-            expected: "ChatCompletionChunk.Choice.Delta.ToolCall",
-            value: elem
-        }, _errorFactory)) && _ao4(elem, _path + ".tool_calls[" + _index9 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".tool_calls[" + _index9 + "]",
-            expected: "ChatCompletionChunk.Choice.Delta.ToolCall",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".tool_calls",
-            expected: "(Array<ChatCompletionChunk.Choice.Delta.ToolCall> | undefined)",
-            value: input.tool_calls
-        }, _errorFactory));
-        const _ao3 = (input, _path, _exceptionable = true) => (undefined === input.arguments || "string" === typeof input.arguments || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".arguments",
-            expected: "(string | undefined)",
-            value: input.arguments
-        }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".name",
-            expected: "(string | undefined)",
-            value: input.name
-        }, _errorFactory));
-        const _ao4 = (input, _path, _exceptionable = true) => ("number" === typeof input.index || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".index",
-            expected: "number",
-            value: input.index
-        }, _errorFactory)) && (undefined === input.id || "string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".id",
-            expected: "(string | undefined)",
-            value: input.id
-        }, _errorFactory)) && (undefined === input["function"] || ("object" === typeof input["function"] && null !== input["function"] && false === Array.isArray(input["function"]) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + '["function"]',
-            expected: "(ChatCompletionChunk.Choice.Delta.ToolCall.Function | undefined)",
-            value: input["function"]
-        }, _errorFactory)) && _ao5(input["function"], _path + '["function"]', _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + '["function"]',
-            expected: "(ChatCompletionChunk.Choice.Delta.ToolCall.Function | undefined)",
-            value: input["function"]
-        }, _errorFactory)) && (undefined === input.type || "function" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".type",
-            expected: '("function" | undefined)',
-            value: input.type
-        }, _errorFactory));
-        const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.arguments || "string" === typeof input.arguments || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".arguments",
-            expected: "(string | undefined)",
-            value: input.arguments
-        }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".name",
-            expected: "(string | undefined)",
-            value: input.name
-        }, _errorFactory));
-        const _ao6 = (input, _path, _exceptionable = true) => (null === input.content || (Array.isArray(input.content) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".content",
-            expected: "(Array<ChatCompletionTokenLogprob> | null)",
-            value: input.content
-        }, _errorFactory)) && input.content.every(((elem, _index10) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".content[" + _index10 + "]",
-            expected: "ChatCompletionTokenLogprob",
-            value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".content[" + _index10 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".content[" + _index10 + "]",
-            expected: "ChatCompletionTokenLogprob",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".content",
-            expected: "(Array<ChatCompletionTokenLogprob> | null)",
-            value: input.content
-        }, _errorFactory)) && (null === input.refusal || (Array.isArray(input.refusal) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".refusal",
-            expected: "(Array<ChatCompletionTokenLogprob> | null)",
-            value: input.refusal
-        }, _errorFactory)) && input.refusal.every(((elem, _index11) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".refusal[" + _index11 + "]",
-            expected: "ChatCompletionTokenLogprob",
-            value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".refusal[" + _index11 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".refusal[" + _index11 + "]",
-            expected: "ChatCompletionTokenLogprob",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".refusal",
-            expected: "(Array<ChatCompletionTokenLogprob> | null)",
-            value: input.refusal
-        }, _errorFactory));
-        const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.token || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".token",
-            expected: "string",
-            value: input.token
-        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes",
-            expected: "(Array<number> | null)",
-            value: input.bytes
-        }, _errorFactory)) && input.bytes.every(((elem, _index12) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes[" + _index12 + "]",
-            expected: "number",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes",
-            expected: "(Array<number> | null)",
-            value: input.bytes
-        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".logprob",
-            expected: "number",
-            value: input.logprob
-        }, _errorFactory)) && ((Array.isArray(input.top_logprobs) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".top_logprobs",
-            expected: "Array<ChatCompletionTokenLogprob.TopLogprob>",
-            value: input.top_logprobs
-        }, _errorFactory)) && input.top_logprobs.every(((elem, _index13) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".top_logprobs[" + _index13 + "]",
-            expected: "ChatCompletionTokenLogprob.TopLogprob",
-            value: elem
-        }, _errorFactory)) && _ao8(elem, _path + ".top_logprobs[" + _index13 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".top_logprobs[" + _index13 + "]",
-            expected: "ChatCompletionTokenLogprob.TopLogprob",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".top_logprobs",
-            expected: "Array<ChatCompletionTokenLogprob.TopLogprob>",
-            value: input.top_logprobs
-        }, _errorFactory));
-        const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.token || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".token",
-            expected: "string",
-            value: input.token
-        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes",
-            expected: "(Array<number> | null)",
-            value: input.bytes
-        }, _errorFactory)) && input.bytes.every(((elem, _index14) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes[" + _index14 + "]",
-            expected: "number",
-            value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".bytes",
-            expected: "(Array<number> | null)",
-            value: input.bytes
-        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".logprob",
-            expected: "number",
-            value: input.logprob
-        }, _errorFactory));
-        const _ao9 = (input, _path, _exceptionable = true) => ("number" === typeof input.completion_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".completion_tokens",
-            expected: "number",
-            value: input.completion_tokens
-        }, _errorFactory)) && ("number" === typeof input.prompt_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".prompt_tokens",
-            expected: "number",
-            value: input.prompt_tokens
-        }, _errorFactory)) && ("number" === typeof input.total_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".total_tokens",
-            expected: "number",
-            value: input.total_tokens
-        }, _errorFactory)) && (undefined === input.completion_tokens_details || ("object" === typeof input.completion_tokens_details && null !== input.completion_tokens_details && false === Array.isArray(input.completion_tokens_details) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".completion_tokens_details",
-            expected: "(CompletionUsage.CompletionTokensDetails | undefined)",
-            value: input.completion_tokens_details
-        }, _errorFactory)) && _ao10(input.completion_tokens_details, _path + ".completion_tokens_details", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".completion_tokens_details",
-            expected: "(CompletionUsage.CompletionTokensDetails | undefined)",
-            value: input.completion_tokens_details
-        }, _errorFactory)) && (undefined === input.prompt_tokens_details || ("object" === typeof input.prompt_tokens_details && null !== input.prompt_tokens_details && false === Array.isArray(input.prompt_tokens_details) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".prompt_tokens_details",
-            expected: "(CompletionUsage.PromptTokensDetails | undefined)",
-            value: input.prompt_tokens_details
-        }, _errorFactory)) && _ao11(input.prompt_tokens_details, _path + ".prompt_tokens_details", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".prompt_tokens_details",
-            expected: "(CompletionUsage.PromptTokensDetails | undefined)",
-            value: input.prompt_tokens_details
-        }, _errorFactory));
-        const _ao10 = (input, _path, _exceptionable = true) => (undefined === input.accepted_prediction_tokens || "number" === typeof input.accepted_prediction_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".accepted_prediction_tokens",
-            expected: "(number | undefined)",
-            value: input.accepted_prediction_tokens
-        }, _errorFactory)) && (undefined === input.audio_tokens || "number" === typeof input.audio_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".audio_tokens",
-            expected: "(number | undefined)",
-            value: input.audio_tokens
-        }, _errorFactory)) && (undefined === input.reasoning_tokens || "number" === typeof input.reasoning_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".reasoning_tokens",
-            expected: "(number | undefined)",
-            value: input.reasoning_tokens
-        }, _errorFactory)) && (undefined === input.rejected_prediction_tokens || "number" === typeof input.rejected_prediction_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".rejected_prediction_tokens",
-            expected: "(number | undefined)",
-            value: input.rejected_prediction_tokens
-        }, _errorFactory));
-        const _ao11 = (input, _path, _exceptionable = true) => (undefined === input.audio_tokens || "number" === typeof input.audio_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".audio_tokens",
-            expected: "(number | undefined)",
-            value: input.audio_tokens
-        }, _errorFactory)) && (undefined === input.cached_tokens || "number" === typeof input.cached_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
-            path: _path + ".cached_tokens",
-            expected: "(number | undefined)",
-            value: input.cached_tokens
-        }, _errorFactory));
-        const __is = input => "object" === typeof input && null !== input && _io0(input);
-        let _errorFactory;
-        const __assert = (input, errorFactory) => {
-            if (false === __is(input)) {
-                _errorFactory = errorFactory;
-                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
-                    method: "json.assertParse",
-                    path: _path + "",
-                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
-                    value: input
-                }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
-                    method: "json.assertParse",
-                    path: _path + "",
-                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
-                    value: input
-                }, _errorFactory))(input, "$input", true);
+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)
             }
-            return input;
-        };
-        return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
-    })()(str);
+        } ]
+    }, {
+        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 accumulate(origin, chunk) {
-    const choices = origin.choices;
-    chunk.choices.forEach((choice => {
-        const accChoice = choices[choice.index];
-        if (accChoice != null) {
-            choices[choice.index] = mergeChoice(accChoice, choice);
-            return;
-        }
-        choices[choice.index] = {
-            index: choice.index,
-            finish_reason: choice.finish_reason ?? null,
-            logprobs: choice.logprobs ?? null,
-            message: {
-                tool_calls: choice.delta.tool_calls !== undefined ? choice.delta.tool_calls.reduce(((acc, cur) => {
-                    acc[cur.index] = {
-                        id: cur.id ?? "",
-                        type: "function",
-                        function: {
-                            name: cur.function?.name ?? "",
-                            arguments: cur.function?.arguments ?? ""
-                        }
-                    };
-                    return acc;
-                }), []) : undefined,
-                content: choice.delta.content ?? null,
-                refusal: choice.delta.refusal ?? null,
-                role: "assistant"
-            }
-        };
-    }));
-    const usage = (() => {
-        if (chunk.usage == null) {
-            return origin.usage;
-        }
-        if (origin.usage == null) {
-            return chunk.usage;
-        }
-        return ChatGptTokenUsageAggregator.sum(origin.usage, chunk.usage);
-    })();
+function createTextPrompt(props) {
+    const prompt = {
+        type: "text",
+        role: props.role,
+        text: props.text
+    };
     return {
-        ...origin,
-        choices,
-        usage
+        ...prompt,
+        toJSON: () => prompt
     };
 }
 
-function merge(chunks) {
-    const firstChunk = chunks[0];
-    if (firstChunk === undefined) {
-        throw new Error("No chunks received");
-    }
-    return chunks.reduce(accumulate, {
-        id: firstChunk.id,
-        choices: [],
-        created: firstChunk.created,
-        model: firstChunk.model,
-        object: "chat.completion",
-        usage: undefined,
-        service_tier: firstChunk.service_tier,
-        system_fingerprint: firstChunk.system_fingerprint
-    });
+function createDescribePrompt(props) {
+    return {
+        type: "describe",
+        text: props.text,
+        executes: props.executes,
+        toJSON: () => ({
+            type: "describe",
+            text: props.text,
+            executes: props.executes.map((execute => execute.toJSON()))
+        })
+    };
 }
 
-function mergeChoice(acc, cur) {
-    var _a;
-    if (acc.finish_reason == null && cur.finish_reason != null) {
-        acc.finish_reason = cur.finish_reason;
-    }
-    if (acc.logprobs == null && cur.logprobs != null) {
-        acc.logprobs = cur.logprobs;
-    }
-    if (cur.delta.content != null) {
-        if (acc.message.content == null) {
-            acc.message.content = cur.delta.content;
-        } else {
-            acc.message.content += cur.delta.content;
-        }
-    }
-    if (cur.delta.refusal != null) {
-        if (acc.message.refusal == null) {
-            acc.message.refusal = cur.delta.refusal;
-        } else {
-            acc.message.refusal += cur.delta.refusal;
-        }
-    }
-    if (cur.delta.tool_calls != null) {
-        (_a = acc.message).tool_calls ?? (_a.tool_calls = []);
-        const toolCalls = acc.message.tool_calls;
-        cur.delta.tool_calls.forEach((toolCall => {
-            const existingToolCall = toolCalls[toolCall.index];
-            if (existingToolCall != null) {
-                toolCalls[toolCall.index] = mergeToolCalls(existingToolCall, toolCall);
-                return;
-            }
-            toolCalls[toolCall.index] = {
-                id: toolCall.id ?? "",
-                type: "function",
-                function: {
-                    name: toolCall.function?.name ?? "",
-                    arguments: toolCall.function?.arguments ?? ""
-                }
-            };
-        }));
-    }
-    return acc;
+function createSelectPrompt(props) {
+    return {
+        type: "select",
+        id: props.id,
+        selections: props.selections,
+        toJSON: () => ({
+            type: "select",
+            id: props.id,
+            selections: props.selections.map((selection => selection.toJSON()))
+        })
+    };
 }
 
-function mergeToolCalls(acc, cur) {
-    if (cur.function != null) {
-        acc.function.arguments += cur.function.arguments ?? "";
-        acc.function.name += cur.function.name ?? "";
-    }
-    acc.id += cur.id ?? "";
-    return acc;
+function createCancelPrompt(props) {
+    return {
+        type: "cancel",
+        id: props.id,
+        selections: props.selections,
+        toJSON: () => ({
+            type: "cancel",
+            id: props.id,
+            selections: props.selections.map((selection => selection.toJSON()))
+        })
+    };
+}
+
+function createExecutePrompt(props) {
+    return {
+        type: "execute",
+        protocol: props.operation.protocol,
+        id: props.id,
+        operation: props.operation,
+        arguments: props.arguments,
+        value: props.value,
+        toJSON: () => ({
+            type: "execute",
+            protocol: props.operation.protocol,
+            id: props.id,
+            operation: props.operation.toJSON(),
+            arguments: props.arguments,
+            value: props.value
+        })
+    };
+}
+
+function createInitializeEvent() {
+    const event = {
+        type: "initialize"
+    };
+    return {
+        type: event.type,
+        toJSON: () => event
+    };
 }
 
-const ChatGptCompletionMessageUtil = {
-    transformCompletionChunk,
-    accumulate,
-    merge,
-    mergeChoice,
-    mergeToolCalls
-};
+function createSelectEvent(props) {
+    return {
+        type: "select",
+        selection: props.selection,
+        toJSON: () => ({
+            type: "select",
+            selection: props.selection.toJSON()
+        }),
+        toPrompt: () => createSelectPrompt({
+            id: v4(),
+            selections: [ props.selection ]
+        })
+    };
+}
 
-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 createCancelEvent(props) {
+    return {
+        type: "cancel",
+        selection: props.selection,
+        toJSON: () => ({
+            type: "cancel",
+            selection: props.selection.toJSON()
+        })
+    };
 }
 
-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));
+function createCallEvent(props) {
+    return {
+        type: "call",
+        id: props.id,
+        operation: props.operation,
+        arguments: props.arguments,
+        toJSON: () => ({
+            type: "call",
+            id: props.id,
+            operation: props.operation.toJSON(),
+            arguments: props.arguments
+        })
+    };
 }
 
-const AgenticaTokenUsageAggregator = {
-    aggregate
-};
+function createValidateEvent(props) {
+    return {
+        type: "validate",
+        id: props.id,
+        operation: props.operation,
+        result: props.result,
+        toJSON: () => ({
+            type: "validate",
+            id: props.id,
+            operation: props.operation.toJSON(),
+            result: props.result
+        })
+    };
+}
 
-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 createExecuteEvent(props) {
+    return {
+        type: "execute",
+        protocol: props.operation.protocol,
+        id: props.id,
+        operation: props.operation,
+        arguments: props.arguments,
+        value: props.value,
+        toJSON: () => ({
+            type: "execute",
+            protocol: props.operation.protocol,
+            id: props.id,
+            operation: props.operation.toJSON(),
+            arguments: props.arguments,
+            value: props.value
+        }),
+        toPrompt: () => createExecutePrompt(props)
+    };
 }
 
-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),
+function createTextEvent(props) {
+    return {
+        type: "text",
+        role: props.role,
+        stream: props.stream,
+        join: props.join,
         toJSON: () => ({
-            protocol: "http",
-            controller: controller.name,
-            function: func.name,
-            name: naming(func.name, ci)
+            type: "text",
+            role: props.role,
+            done: props.done(),
+            text: props.get()
+        }),
+        toPrompt: () => ({
+            type: "text",
+            role: props.role,
+            text: props.get(),
+            toJSON: () => ({
+                type: "text",
+                role: props.role,
+                text: props.get()
+            })
         })
-    }))) : 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)
+    };
+}
+
+function createDescribeEvent(props) {
+    return {
+        type: "describe",
+        executes: props.executes,
+        stream: props.stream,
+        join: props.join,
+        toJSON: () => ({
+            type: "describe",
+            executes: props.executes.map((execute => execute.toJSON())),
+            done: props.done(),
+            text: props.get()
+        }),
+        toPrompt: () => ({
+            type: "describe",
+            executes: props.executes,
+            text: props.get(),
+            toJSON: () => ({
+                type: "describe",
+                executes: props.executes.map((execute => execute.toJSON())),
+                text: props.get()
+            })
         })
-    }))))).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);
-    }
+    };
+}
+
+function createRequestEvent(props) {
     return {
-        array,
-        divided,
-        flat,
-        group
+        type: "request",
+        source: props.source,
+        body: props.body,
+        options: props.options
     };
 }
 
-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)));
+function createResponseEvent(props) {
+    return {
+        type: "response",
+        source: props.source,
+        body: props.body,
+        options: props.options,
+        stream: props.stream,
+        join: props.join
+    };
 }
 
-const AgenticaOperationComposer = {
-    compose
-};
+var AgenticaConstant;
 
-async function readAll(stream) {
-    const reader = stream.getReader();
-    const result = [];
-    while (true) {
-        const {done, value} = await reader.read();
-        if (done) {
-            break;
+(function(AgenticaConstant) {
+    AgenticaConstant.RETRY = 3;
+    AgenticaConstant.ELITICISM = true;
+})(AgenticaConstant || (AgenticaConstant = {}));
+
+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);
         }
-        result.push(value);
+        return this.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);
+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 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);
     }
-    return acc;
+    const locale = config?.locale ?? getLocale.get();
+    const timezone = config?.timezone ?? getTimezone.get();
+    return AgenticaSystemPrompt.COMMON.replace("${locale}", locale).replace("${timezone}", timezone);
 }
 
-function to(value) {
-    const stream = new ReadableStream({
-        start: controller => {
-            controller.enqueue(value);
-            controller.close();
-        }
-    });
-    return stream;
-}
+const AgenticaDefaultPrompt = {
+    write
+};
 
-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();
-            }
-        }
-    });
+function createOperationSelection(props) {
+    return {
+        operation: props.operation,
+        reason: props.reason,
+        toJSON: () => ({
+            operation: props.operation.toJSON(),
+            reason: props.reason
+        })
+    };
 }
 
-const StreamUtil = {
-    readAll,
-    reduce,
-    to,
-    transform: transform$1
-};
+var ByteArrayUtil;
 
-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: ""
-        } ];
+(function(ByteArrayUtil) {
+    function toUtf8(byteArray) {
+        return (new TextDecoder).decode(byteArray);
     }
-    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
+    ByteArrayUtil.toUtf8 = toUtf8;
+})(ByteArrayUtil || (ByteArrayUtil = {}));
+
+function sumCompletionTokenDetail(x, y) {
+    return {
+        accepted_prediction_tokens: (x.accepted_prediction_tokens ?? 0) + (y.accepted_prediction_tokens ?? 0),
+        reasoning_tokens: (x.reasoning_tokens ?? 0) + (y.reasoning_tokens ?? 0),
+        rejected_prediction_tokens: (x.rejected_prediction_tokens ?? 0) + (y.rejected_prediction_tokens ?? 0)
+    };
+}
+
+function sumPromptTokenDetail(x, y) {
+    return {
+        audio_tokens: (x.audio_tokens ?? 0) + (y.audio_tokens ?? 0),
+        cached_tokens: (x.cached_tokens ?? 0) + (y.cached_tokens ?? 0)
+    };
+}
+
+function sum(x, y) {
+    return {
+        prompt_tokens: (x.prompt_tokens ?? 0) + (y.prompt_tokens ?? 0),
+        completion_tokens: (x.completion_tokens ?? 0) + (y.completion_tokens ?? 0),
+        total_tokens: (x.total_tokens ?? 0) + (y.total_tokens ?? 0),
+        completion_tokens_details: sumCompletionTokenDetail(x.completion_tokens_details ?? {
+            accepted_prediction_tokens: 0,
+            reasoning_tokens: 0,
+            rejected_prediction_tokens: 0
+        }, y.completion_tokens_details ?? {
+            accepted_prediction_tokens: 0,
+            reasoning_tokens: 0,
+            rejected_prediction_tokens: 0
+        }),
+        prompt_tokens_details: sumPromptTokenDetail(x.prompt_tokens_details ?? {
+            audio_tokens: 0,
+            cached_tokens: 0
+        }, y.prompt_tokens_details ?? {
+            audio_tokens: 0,
+            cached_tokens: 0
+        })
+    };
+}
+
+const ChatGptTokenUsageAggregator = {
+    sum,
+    sumCompletionTokenDetail,
+    sumPromptTokenDetail
+};
+
+function transformCompletionChunk(source) {
+    const str = source instanceof Uint8Array ? ByteArrayUtil.toUtf8(source) : source;
+    return (() => {
+        const _io0 = input => "string" === typeof input.id && (Array.isArray(input.choices) && input.choices.every((elem => "object" === typeof elem && null !== elem && _io1(elem)))) && "number" === typeof input.created && "string" === typeof input.model && "chat.completion.chunk" === input.object && (null === input.service_tier || undefined === input.service_tier || "scale" === input.service_tier || "default" === input.service_tier) && (undefined === input.system_fingerprint || "string" === typeof input.system_fingerprint) && (null === input.usage || undefined === input.usage || "object" === typeof input.usage && null !== input.usage && _io9(input.usage));
+        const _io1 = input => "object" === typeof input.delta && null !== input.delta && false === Array.isArray(input.delta) && _io2(input.delta) && (null === input.finish_reason || "function_call" === input.finish_reason || "stop" === input.finish_reason || "length" === input.finish_reason || "tool_calls" === input.finish_reason || "content_filter" === input.finish_reason) && "number" === typeof input.index && (null === input.logprobs || undefined === input.logprobs || "object" === typeof input.logprobs && null !== input.logprobs && _io6(input.logprobs));
+        const _io2 = input => (null === input.content || undefined === input.content || "string" === typeof input.content) && (undefined === input.function_call || "object" === typeof input.function_call && null !== input.function_call && false === Array.isArray(input.function_call) && _io3(input.function_call)) && (null === input.refusal || undefined === input.refusal || "string" === typeof input.refusal) && (undefined === input.role || "assistant" === input.role || "user" === input.role || "developer" === input.role || "system" === input.role || "tool" === input.role) && (undefined === input.tool_calls || Array.isArray(input.tool_calls) && input.tool_calls.every((elem => "object" === typeof elem && null !== elem && _io4(elem))));
+        const _io3 = input => (undefined === input.arguments || "string" === typeof input.arguments) && (undefined === input.name || "string" === typeof input.name);
+        const _io4 = input => "number" === typeof input.index && (undefined === input.id || "string" === typeof input.id) && (undefined === input["function"] || "object" === typeof input["function"] && null !== input["function"] && false === Array.isArray(input["function"]) && _io5(input["function"])) && (undefined === input.type || "function" === input.type);
+        const _io5 = input => (undefined === input.arguments || "string" === typeof input.arguments) && (undefined === input.name || "string" === typeof input.name);
+        const _io6 = input => (null === input.content || Array.isArray(input.content) && input.content.every((elem => "object" === typeof elem && null !== elem && _io7(elem)))) && (null === input.refusal || Array.isArray(input.refusal) && input.refusal.every((elem => "object" === typeof elem && null !== elem && _io7(elem))));
+        const _io7 = input => "string" === typeof input.token && (null === input.bytes || Array.isArray(input.bytes) && input.bytes.every((elem => "number" === typeof elem))) && "number" === typeof input.logprob && (Array.isArray(input.top_logprobs) && input.top_logprobs.every((elem => "object" === typeof elem && null !== elem && _io8(elem))));
+        const _io8 = input => "string" === typeof input.token && (null === input.bytes || Array.isArray(input.bytes) && input.bytes.every((elem => "number" === typeof elem))) && "number" === typeof input.logprob;
+        const _io9 = input => "number" === typeof input.completion_tokens && "number" === typeof input.prompt_tokens && "number" === typeof input.total_tokens && (undefined === input.completion_tokens_details || "object" === typeof input.completion_tokens_details && null !== input.completion_tokens_details && false === Array.isArray(input.completion_tokens_details) && _io10(input.completion_tokens_details)) && (undefined === input.prompt_tokens_details || "object" === typeof input.prompt_tokens_details && null !== input.prompt_tokens_details && false === Array.isArray(input.prompt_tokens_details) && _io11(input.prompt_tokens_details));
+        const _io10 = input => (undefined === input.accepted_prediction_tokens || "number" === typeof input.accepted_prediction_tokens) && (undefined === input.audio_tokens || "number" === typeof input.audio_tokens) && (undefined === input.reasoning_tokens || "number" === typeof input.reasoning_tokens) && (undefined === input.rejected_prediction_tokens || "number" === typeof input.rejected_prediction_tokens);
+        const _io11 = input => (undefined === input.audio_tokens || "number" === typeof input.audio_tokens) && (undefined === input.cached_tokens || "number" === typeof input.cached_tokens);
+        const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".id",
+            expected: "string",
+            value: input.id
+        }, _errorFactory)) && ((Array.isArray(input.choices) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".choices",
+            expected: "Array<ChatCompletionChunk.Choice>",
+            value: input.choices
+        }, _errorFactory)) && input.choices.every(((elem, _index8) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".choices[" + _index8 + "]",
+            expected: "ChatCompletionChunk.Choice",
+            value: elem
+        }, _errorFactory)) && _ao1(elem, _path + ".choices[" + _index8 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".choices[" + _index8 + "]",
+            expected: "ChatCompletionChunk.Choice",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".choices",
+            expected: "Array<ChatCompletionChunk.Choice>",
+            value: input.choices
+        }, _errorFactory)) && ("number" === typeof input.created || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".created",
+            expected: "number",
+            value: input.created
+        }, _errorFactory)) && ("string" === typeof input.model || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".model",
+            expected: "string",
+            value: input.model
+        }, _errorFactory)) && ("chat.completion.chunk" === input.object || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".object",
+            expected: '"chat.completion.chunk"',
+            value: input.object
+        }, _errorFactory)) && (null === input.service_tier || undefined === input.service_tier || "scale" === input.service_tier || "default" === input.service_tier || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".service_tier",
+            expected: '("default" | "scale" | null | undefined)',
+            value: input.service_tier
+        }, _errorFactory)) && (undefined === input.system_fingerprint || "string" === typeof input.system_fingerprint || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".system_fingerprint",
+            expected: "(string | undefined)",
+            value: input.system_fingerprint
+        }, _errorFactory)) && (null === input.usage || undefined === input.usage || ("object" === typeof input.usage && null !== input.usage || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".usage",
+            expected: "(CompletionUsage | null | undefined)",
+            value: input.usage
+        }, _errorFactory)) && _ao9(input.usage, _path + ".usage", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".usage",
+            expected: "(CompletionUsage | null | undefined)",
+            value: input.usage
+        }, _errorFactory));
+        const _ao1 = (input, _path, _exceptionable = true) => (("object" === typeof input.delta && null !== input.delta && false === Array.isArray(input.delta) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".delta",
+            expected: "ChatCompletionChunk.Choice.Delta",
+            value: input.delta
+        }, _errorFactory)) && _ao2(input.delta, _path + ".delta", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".delta",
+            expected: "ChatCompletionChunk.Choice.Delta",
+            value: input.delta
+        }, _errorFactory)) && (null === input.finish_reason || "function_call" === input.finish_reason || "stop" === input.finish_reason || "length" === input.finish_reason || "tool_calls" === input.finish_reason || "content_filter" === input.finish_reason || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".finish_reason",
+            expected: '("content_filter" | "function_call" | "length" | "stop" | "tool_calls" | null)',
+            value: input.finish_reason
+        }, _errorFactory)) && ("number" === typeof input.index || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".index",
+            expected: "number",
+            value: input.index
+        }, _errorFactory)) && (null === input.logprobs || undefined === input.logprobs || ("object" === typeof input.logprobs && null !== input.logprobs || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".logprobs",
+            expected: "(ChatCompletionChunk.Choice.Logprobs | null | undefined)",
+            value: input.logprobs
+        }, _errorFactory)) && _ao6(input.logprobs, _path + ".logprobs", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".logprobs",
+            expected: "(ChatCompletionChunk.Choice.Logprobs | null | undefined)",
+            value: input.logprobs
+        }, _errorFactory));
+        const _ao2 = (input, _path, _exceptionable = true) => (null === input.content || undefined === input.content || "string" === typeof input.content || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".content",
+            expected: "(null | string | undefined)",
+            value: input.content
+        }, _errorFactory)) && (undefined === input.function_call || ("object" === typeof input.function_call && null !== input.function_call && false === Array.isArray(input.function_call) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".function_call",
+            expected: "(ChatCompletionChunk.Choice.Delta.FunctionCall | undefined)",
+            value: input.function_call
+        }, _errorFactory)) && _ao3(input.function_call, _path + ".function_call", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".function_call",
+            expected: "(ChatCompletionChunk.Choice.Delta.FunctionCall | undefined)",
+            value: input.function_call
+        }, _errorFactory)) && (null === input.refusal || undefined === input.refusal || "string" === typeof input.refusal || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".refusal",
+            expected: "(null | string | undefined)",
+            value: input.refusal
+        }, _errorFactory)) && (undefined === input.role || "assistant" === input.role || "user" === input.role || "developer" === input.role || "system" === input.role || "tool" === input.role || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".role",
+            expected: '("assistant" | "developer" | "system" | "tool" | "user" | undefined)',
+            value: input.role
+        }, _errorFactory)) && (undefined === input.tool_calls || (Array.isArray(input.tool_calls) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".tool_calls",
+            expected: "(Array<ChatCompletionChunk.Choice.Delta.ToolCall> | undefined)",
+            value: input.tool_calls
+        }, _errorFactory)) && input.tool_calls.every(((elem, _index9) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".tool_calls[" + _index9 + "]",
+            expected: "ChatCompletionChunk.Choice.Delta.ToolCall",
+            value: elem
+        }, _errorFactory)) && _ao4(elem, _path + ".tool_calls[" + _index9 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".tool_calls[" + _index9 + "]",
+            expected: "ChatCompletionChunk.Choice.Delta.ToolCall",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".tool_calls",
+            expected: "(Array<ChatCompletionChunk.Choice.Delta.ToolCall> | undefined)",
+            value: input.tool_calls
+        }, _errorFactory));
+        const _ao3 = (input, _path, _exceptionable = true) => (undefined === input.arguments || "string" === typeof input.arguments || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".arguments",
+            expected: "(string | undefined)",
+            value: input.arguments
+        }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".name",
+            expected: "(string | undefined)",
+            value: input.name
+        }, _errorFactory));
+        const _ao4 = (input, _path, _exceptionable = true) => ("number" === typeof input.index || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".index",
+            expected: "number",
+            value: input.index
+        }, _errorFactory)) && (undefined === input.id || "string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".id",
+            expected: "(string | undefined)",
+            value: input.id
+        }, _errorFactory)) && (undefined === input["function"] || ("object" === typeof input["function"] && null !== input["function"] && false === Array.isArray(input["function"]) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + '["function"]',
+            expected: "(ChatCompletionChunk.Choice.Delta.ToolCall.Function | undefined)",
+            value: input["function"]
+        }, _errorFactory)) && _ao5(input["function"], _path + '["function"]', _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + '["function"]',
+            expected: "(ChatCompletionChunk.Choice.Delta.ToolCall.Function | undefined)",
+            value: input["function"]
+        }, _errorFactory)) && (undefined === input.type || "function" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".type",
+            expected: '("function" | undefined)',
+            value: input.type
+        }, _errorFactory));
+        const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.arguments || "string" === typeof input.arguments || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".arguments",
+            expected: "(string | undefined)",
+            value: input.arguments
+        }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".name",
+            expected: "(string | undefined)",
+            value: input.name
+        }, _errorFactory));
+        const _ao6 = (input, _path, _exceptionable = true) => (null === input.content || (Array.isArray(input.content) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".content",
+            expected: "(Array<ChatCompletionTokenLogprob> | null)",
+            value: input.content
+        }, _errorFactory)) && input.content.every(((elem, _index10) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".content[" + _index10 + "]",
+            expected: "ChatCompletionTokenLogprob",
+            value: elem
+        }, _errorFactory)) && _ao7(elem, _path + ".content[" + _index10 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".content[" + _index10 + "]",
+            expected: "ChatCompletionTokenLogprob",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".content",
+            expected: "(Array<ChatCompletionTokenLogprob> | null)",
+            value: input.content
+        }, _errorFactory)) && (null === input.refusal || (Array.isArray(input.refusal) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".refusal",
+            expected: "(Array<ChatCompletionTokenLogprob> | null)",
+            value: input.refusal
+        }, _errorFactory)) && input.refusal.every(((elem, _index11) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".refusal[" + _index11 + "]",
+            expected: "ChatCompletionTokenLogprob",
+            value: elem
+        }, _errorFactory)) && _ao7(elem, _path + ".refusal[" + _index11 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".refusal[" + _index11 + "]",
+            expected: "ChatCompletionTokenLogprob",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".refusal",
+            expected: "(Array<ChatCompletionTokenLogprob> | null)",
+            value: input.refusal
+        }, _errorFactory));
+        const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.token || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".token",
+            expected: "string",
+            value: input.token
+        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes",
+            expected: "(Array<number> | null)",
+            value: input.bytes
+        }, _errorFactory)) && input.bytes.every(((elem, _index12) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes[" + _index12 + "]",
+            expected: "number",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes",
+            expected: "(Array<number> | null)",
+            value: input.bytes
+        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".logprob",
+            expected: "number",
+            value: input.logprob
+        }, _errorFactory)) && ((Array.isArray(input.top_logprobs) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".top_logprobs",
+            expected: "Array<ChatCompletionTokenLogprob.TopLogprob>",
+            value: input.top_logprobs
+        }, _errorFactory)) && input.top_logprobs.every(((elem, _index13) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".top_logprobs[" + _index13 + "]",
+            expected: "ChatCompletionTokenLogprob.TopLogprob",
+            value: elem
+        }, _errorFactory)) && _ao8(elem, _path + ".top_logprobs[" + _index13 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".top_logprobs[" + _index13 + "]",
+            expected: "ChatCompletionTokenLogprob.TopLogprob",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".top_logprobs",
+            expected: "Array<ChatCompletionTokenLogprob.TopLogprob>",
+            value: input.top_logprobs
+        }, _errorFactory));
+        const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.token || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".token",
+            expected: "string",
+            value: input.token
+        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes",
+            expected: "(Array<number> | null)",
+            value: input.bytes
+        }, _errorFactory)) && input.bytes.every(((elem, _index14) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes[" + _index14 + "]",
+            expected: "number",
+            value: elem
+        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".bytes",
+            expected: "(Array<number> | null)",
+            value: input.bytes
+        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".logprob",
+            expected: "number",
+            value: input.logprob
+        }, _errorFactory));
+        const _ao9 = (input, _path, _exceptionable = true) => ("number" === typeof input.completion_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".completion_tokens",
+            expected: "number",
+            value: input.completion_tokens
+        }, _errorFactory)) && ("number" === typeof input.prompt_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".prompt_tokens",
+            expected: "number",
+            value: input.prompt_tokens
+        }, _errorFactory)) && ("number" === typeof input.total_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".total_tokens",
+            expected: "number",
+            value: input.total_tokens
+        }, _errorFactory)) && (undefined === input.completion_tokens_details || ("object" === typeof input.completion_tokens_details && null !== input.completion_tokens_details && false === Array.isArray(input.completion_tokens_details) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".completion_tokens_details",
+            expected: "(CompletionUsage.CompletionTokensDetails | undefined)",
+            value: input.completion_tokens_details
+        }, _errorFactory)) && _ao10(input.completion_tokens_details, _path + ".completion_tokens_details", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".completion_tokens_details",
+            expected: "(CompletionUsage.CompletionTokensDetails | undefined)",
+            value: input.completion_tokens_details
+        }, _errorFactory)) && (undefined === input.prompt_tokens_details || ("object" === typeof input.prompt_tokens_details && null !== input.prompt_tokens_details && false === Array.isArray(input.prompt_tokens_details) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".prompt_tokens_details",
+            expected: "(CompletionUsage.PromptTokensDetails | undefined)",
+            value: input.prompt_tokens_details
+        }, _errorFactory)) && _ao11(input.prompt_tokens_details, _path + ".prompt_tokens_details", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".prompt_tokens_details",
+            expected: "(CompletionUsage.PromptTokensDetails | undefined)",
+            value: input.prompt_tokens_details
+        }, _errorFactory));
+        const _ao10 = (input, _path, _exceptionable = true) => (undefined === input.accepted_prediction_tokens || "number" === typeof input.accepted_prediction_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".accepted_prediction_tokens",
+            expected: "(number | undefined)",
+            value: input.accepted_prediction_tokens
+        }, _errorFactory)) && (undefined === input.audio_tokens || "number" === typeof input.audio_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".audio_tokens",
+            expected: "(number | undefined)",
+            value: input.audio_tokens
+        }, _errorFactory)) && (undefined === input.reasoning_tokens || "number" === typeof input.reasoning_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".reasoning_tokens",
+            expected: "(number | undefined)",
+            value: input.reasoning_tokens
+        }, _errorFactory)) && (undefined === input.rejected_prediction_tokens || "number" === typeof input.rejected_prediction_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".rejected_prediction_tokens",
+            expected: "(number | undefined)",
+            value: input.rejected_prediction_tokens
+        }, _errorFactory));
+        const _ao11 = (input, _path, _exceptionable = true) => (undefined === input.audio_tokens || "number" === typeof input.audio_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".audio_tokens",
+            expected: "(number | undefined)",
+            value: input.audio_tokens
+        }, _errorFactory)) && (undefined === input.cached_tokens || "number" === typeof input.cached_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "json.assertParse",
+            path: _path + ".cached_tokens",
+            expected: "(number | undefined)",
+            value: input.cached_tokens
+        }, _errorFactory));
+        const __is = input => "object" === typeof input && null !== input && _io0(input);
+        let _errorFactory;
+        const __assert = (input, errorFactory) => {
+            if (false === __is(input)) {
+                _errorFactory = errorFactory;
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+                    method: "json.assertParse",
+                    path: _path + "",
+                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
+                    value: input
+                }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+                    method: "json.assertParse",
+                    path: _path + "",
+                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
+                    value: input
+                }, _errorFactory))(input, "$input", true);
             }
-        })
-    } ];
-}
-
-function createTextPrompt(props) {
-    const prompt = {
-        type: "text",
-        role: props.role,
-        text: props.text
-    };
-    return {
-        ...prompt,
-        toJSON: () => prompt
-    };
-}
-
-function createDescribePrompt(props) {
-    return {
-        type: "describe",
-        text: props.text,
-        executes: props.executes,
-        toJSON: () => ({
-            type: "describe",
-            text: props.text,
-            executes: props.executes.map((execute => execute.toJSON()))
-        })
-    };
-}
-
-function createSelectPrompt(props) {
-    return {
-        type: "select",
-        id: props.id,
-        selections: props.selections,
-        toJSON: () => ({
-            type: "select",
-            id: props.id,
-            selections: props.selections.map((selection => selection.toJSON()))
-        })
-    };
-}
-
-function createCancelPrompt(props) {
-    return {
-        type: "cancel",
-        id: props.id,
-        selections: props.selections,
-        toJSON: () => ({
-            type: "cancel",
-            id: props.id,
-            selections: props.selections.map((selection => selection.toJSON()))
-        })
-    };
-}
-
-function createExecutePrompt(props) {
-    return {
-        type: "execute",
-        protocol: props.operation.protocol,
-        id: props.id,
-        operation: props.operation,
-        arguments: props.arguments,
-        value: props.value,
-        toJSON: () => ({
-            type: "execute",
-            protocol: props.operation.protocol,
-            id: props.id,
-            operation: props.operation.toJSON(),
-            arguments: props.arguments,
-            value: props.value
-        })
-    };
+            return input;
+        };
+        return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
+    })()(str);
 }
 
-function createOperationSelection(props) {
+function accumulate(origin, chunk) {
+    const choices = origin.choices;
+    chunk.choices.forEach((choice => {
+        const accChoice = choices[choice.index];
+        if (accChoice != null) {
+            choices[choice.index] = mergeChoice(accChoice, choice);
+            return;
+        }
+        choices[choice.index] = {
+            index: choice.index,
+            finish_reason: choice.finish_reason ?? null,
+            logprobs: choice.logprobs ?? null,
+            message: {
+                tool_calls: choice.delta.tool_calls !== undefined ? choice.delta.tool_calls.reduce(((acc, cur) => {
+                    acc[cur.index] = {
+                        id: cur.id ?? "",
+                        type: "function",
+                        function: {
+                            name: cur.function?.name ?? "",
+                            arguments: cur.function?.arguments ?? ""
+                        }
+                    };
+                    return acc;
+                }), []) : undefined,
+                content: choice.delta.content ?? null,
+                refusal: choice.delta.refusal ?? null,
+                role: "assistant"
+            }
+        };
+    }));
+    const usage = (() => {
+        if (chunk.usage == null) {
+            return origin.usage;
+        }
+        if (origin.usage == null) {
+            return chunk.usage;
+        }
+        return ChatGptTokenUsageAggregator.sum(origin.usage, chunk.usage);
+    })();
     return {
-        operation: props.operation,
-        reason: props.reason,
-        toJSON: () => ({
-            operation: props.operation.toJSON(),
-            reason: props.reason
-        })
+        ...origin,
+        choices,
+        usage
     };
 }
 
-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
-        });
+function merge(chunks) {
+    const firstChunk = chunks[0];
+    if (firstChunk === undefined) {
+        throw new Error("No chunks received");
     }
-    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
-        })))
+    return chunks.reduce(accumulate, {
+        id: firstChunk.id,
+        choices: [],
+        created: firstChunk.created,
+        model: firstChunk.model,
+        object: "chat.completion",
+        usage: undefined,
+        service_tier: firstChunk.service_tier,
+        system_fingerprint: firstChunk.system_fingerprint
     });
 }
 
-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})`);
+function mergeChoice(acc, cur) {
+    var _a;
+    if (acc.finish_reason == null && cur.finish_reason != null) {
+        acc.finish_reason = cur.finish_reason;
     }
-    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 ]
-        })
-    };
-}
-
-function createCancelEvent(props) {
-    return {
-        type: "cancel",
-        selection: props.selection,
-        toJSON: () => ({
-            type: "cancel",
-            selection: props.selection.toJSON()
-        })
-    };
-}
-
-function createCallEvent(props) {
-    return {
-        type: "call",
-        id: props.id,
-        operation: props.operation,
-        arguments: props.arguments,
-        toJSON: () => ({
-            type: "call",
-            id: props.id,
-            operation: props.operation.toJSON(),
-            arguments: props.arguments
-        })
-    };
-}
-
-function createValidateEvent(props) {
-    return {
-        type: "validate",
-        id: props.id,
-        operation: props.operation,
-        result: props.result,
-        toJSON: () => ({
-            type: "validate",
-            id: props.id,
-            operation: props.operation.toJSON(),
-            result: props.result
-        })
-    };
-}
-
-function createExecuteEvent(props) {
-    return {
-        type: "execute",
-        protocol: props.operation.protocol,
-        id: props.id,
-        operation: props.operation,
-        arguments: props.arguments,
-        value: props.value,
-        toJSON: () => ({
-            type: "execute",
-            protocol: props.operation.protocol,
-            id: props.id,
-            operation: props.operation.toJSON(),
-            arguments: props.arguments,
-            value: props.value
-        }),
-        toPrompt: () => createExecutePrompt(props)
-    };
+    if (acc.logprobs == null && cur.logprobs != null) {
+        acc.logprobs = cur.logprobs;
+    }
+    if (cur.delta.content != null) {
+        if (acc.message.content == null) {
+            acc.message.content = cur.delta.content;
+        } else {
+            acc.message.content += cur.delta.content;
+        }
+    }
+    if (cur.delta.refusal != null) {
+        if (acc.message.refusal == null) {
+            acc.message.refusal = cur.delta.refusal;
+        } else {
+            acc.message.refusal += cur.delta.refusal;
+        }
+    }
+    if (cur.delta.tool_calls != null) {
+        (_a = acc.message).tool_calls ?? (_a.tool_calls = []);
+        const toolCalls = acc.message.tool_calls;
+        cur.delta.tool_calls.forEach((toolCall => {
+            const existingToolCall = toolCalls[toolCall.index];
+            if (existingToolCall != null) {
+                toolCalls[toolCall.index] = mergeToolCalls(existingToolCall, toolCall);
+                return;
+            }
+            toolCalls[toolCall.index] = {
+                id: toolCall.id ?? "",
+                type: "function",
+                function: {
+                    name: toolCall.function?.name ?? "",
+                    arguments: toolCall.function?.arguments ?? ""
+                }
+            };
+        }));
+    }
+    return acc;
 }
 
-function createTextEvent(props) {
-    return {
-        type: "text",
-        role: props.role,
-        stream: props.stream,
-        join: props.join,
-        toJSON: () => ({
-            type: "text",
-            role: props.role,
-            done: props.done(),
-            text: props.get()
-        }),
-        toPrompt: () => ({
-            type: "text",
-            role: props.role,
-            text: props.get(),
-            toJSON: () => ({
-                type: "text",
-                role: props.role,
-                text: props.get()
-            })
-        })
-    };
+function mergeToolCalls(acc, cur) {
+    if (cur.function != null) {
+        acc.function.arguments += cur.function.arguments ?? "";
+        acc.function.name += cur.function.name ?? "";
+    }
+    acc.id += cur.id ?? "";
+    return acc;
 }
 
-function createDescribeEvent(props) {
-    return {
-        type: "describe",
-        executes: props.executes,
-        stream: props.stream,
-        join: props.join,
-        toJSON: () => ({
-            type: "describe",
-            executes: props.executes.map((execute => execute.toJSON())),
-            done: props.done(),
-            text: props.get()
-        }),
-        toPrompt: () => ({
-            type: "describe",
-            executes: props.executes,
-            text: props.get(),
-            toJSON: () => ({
-                type: "describe",
-                executes: props.executes.map((execute => execute.toJSON())),
-                text: props.get()
-            })
-        })
-    };
+const ChatGptCompletionMessageUtil = {
+    transformCompletionChunk,
+    accumulate,
+    merge,
+    mergeChoice,
+    mergeToolCalls
+};
+
+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;
 }
 
-function createRequestEvent(props) {
-    return {
-        type: "request",
-        source: props.source,
-        body: props.body,
-        options: props.options
-    };
+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 createResponseEvent(props) {
-    return {
-        type: "response",
-        source: props.source,
-        body: props.body,
-        options: props.options,
-        stream: props.stream,
-        join: props.join
-    };
+function to(value) {
+    const stream = new ReadableStream({
+        start: controller => {
+            controller.enqueue(value);
+            controller.close();
+        }
+    });
+    return stream;
 }
 
-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."
-};
+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 NOT_MOUNTED_YET = {};
+const StreamUtil = {
+    readAll,
+    reduce,
+    to,
+    transform: transform$1
+};
 
-class Singleton {
-    constructor(closure) {
-        this.closure_ = closure;
-        this.value_ = NOT_MOUNTED_YET;
+async function cancelFunction(ctx, reference) {
+    const index = ctx.stack.findIndex((item => item.operation.name === reference.name));
+    if (index === -1) {
+        return null;
     }
-    get(...args) {
-        if (this.value_ === NOT_MOUNTED_YET) {
-            this.value_ = this.closure_(...args);
+    const item = ctx.stack[index];
+    ctx.stack.splice(index, 1);
+    await ctx.dispatch(createCancelEvent({
+        selection: createOperationSelection({
+            operation: item.operation,
+            reason: reference.reason
+        })
+    }));
+    return item;
+}
+
+async function call(ctx) {
+    const completionStream = await ctx.request("call", {
+        messages: [ {
+            role: "system",
+            content: AgenticaDefaultPrompt.write(ctx.config)
+        }, ...ctx.histories.map(decodePrompt).flat(), {
+            role: "user",
+            content: ctx.prompt.text
+        }, {
+            role: "system",
+            content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
+        } ],
+        tools: ctx.stack.map((s => ({
+            type: "function",
+            function: {
+                name: s.operation.name,
+                description: s.operation.function.description,
+                parameters: s.operation.function.separated !== undefined ? s.operation.function.separated.llm ?? {
+                    type: "object",
+                    properties: {},
+                    required: [],
+                    additionalProperties: false,
+                    $defs: {}
+                } : s.operation.function.parameters
+            }
+        }))),
+        tool_choice: "auto",
+        parallel_tool_calls: false
+    });
+    const closures = [];
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+    for (const choice of completion.choices) {
+        for (const tc of choice.message.tool_calls ?? []) {
+            if (tc.type === "function") {
+                const operation = ctx.operations.flat.get(tc.function.name);
+                if (operation === undefined) {
+                    continue;
+                }
+                closures.push((async () => {
+                    const call = createCallEvent({
+                        id: tc.id,
+                        operation,
+                        arguments: JSON.parse(tc.function.arguments)
+                    });
+                    if (call.operation.protocol === "http") {
+                        fillHttpArguments({
+                            operation: call.operation,
+                            arguments: call.arguments
+                        });
+                    }
+                    await ctx.dispatch(call);
+                    const execute = await propagate(ctx, call, 0);
+                    void ctx.dispatch(createExecuteEvent({
+                        id: call.id,
+                        operation: call.operation,
+                        arguments: execute.arguments,
+                        value: execute.value
+                    }));
+                    await cancelFunction(ctx, {
+                        name: call.operation.name,
+                        reason: "completed"
+                    });
+                    void ctx.dispatch(createCancelEvent({
+                        selection: createOperationSelection({
+                            operation: call.operation,
+                            reason: "complete"
+                        })
+                    }));
+                    return [ execute, createCancelPrompt({
+                        id: call.id,
+                        selections: [ createOperationSelection({
+                            operation: call.operation,
+                            reason: "complete"
+                        }) ]
+                    }) ];
+                }));
+            }
+        }
+        if (choice.message.role === "assistant" && choice.message.content !== null && choice.message.content.length > 0) {
+            closures.push((async () => {
+                const value = createTextPrompt({
+                    role: "assistant",
+                    text: choice.message.content
+                });
+                void ctx.dispatch(createTextEvent({
+                    role: "assistant",
+                    get: () => value.text,
+                    done: () => true,
+                    stream: StreamUtil.to(value.text),
+                    join: async () => Promise.resolve(value.text)
+                }));
+                return [ value ];
+            }));
         }
-        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);
+    return (await Promise.all(closures.map((async fn => fn())))).flat();
 }
 
-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
-            });
-        }
-    }
-    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 = [];
+async function propagate(ctx, call, retry) {
+    if (call.operation.protocol === "http") {
+        const check = call.operation.function.validate(call.arguments);
+        if (check.success === false) {
+            void ctx.dispatch(createValidateEvent({
+                id: call.id,
+                operation: call.operation,
+                result: check
+            }));
+            if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
+                const trial = await correct(ctx, call, retry, check.errors);
+                if (trial !== null) {
+                    return trial;
+                }
             }
-            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
+        try {
+            const response = await executeHttpOperation(call.operation, call.arguments);
+            const success = ((response.status === 400 || response.status === 404 || response.status === 422) && retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) && typeof response.body) === false;
+            return (success === false ? await correct(ctx, call, retry, response.body) : null) ?? createExecutePrompt({
+                operation: call.operation,
+                id: call.id,
+                arguments: call.arguments,
+                value: response
+            });
+        } catch (error) {
+            return createExecutePrompt({
+                operation: call.operation,
+                id: call.id,
+                arguments: call.arguments,
+                value: {
+                    status: 500,
+                    headers: {},
+                    body: error instanceof Error ? {
+                        ...error,
+                        name: error.name,
+                        message: error.message
+                    } : error
+                }
             });
         }
-        this.closeResolvers.forEach((resolve => resolve()));
-    }
-    async waitUntilEmpty() {
-        if (this.isEmpty()) {
-            return Promise.resolve();
+    } else {
+        const check = call.operation.function.validate(call.arguments);
+        if (check.success === false) {
+            void ctx.dispatch(createValidateEvent({
+                id: call.id,
+                operation: call.operation,
+                result: check
+            }));
+            return (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) ? await correct(ctx, call, retry, check.errors) : null) ?? createExecutePrompt({
+                id: call.id,
+                operation: call.operation,
+                arguments: call.arguments,
+                value: {
+                    name: "TypeGuardError",
+                    message: "Invalid arguments.",
+                    errors: check.errors
+                }
+            });
         }
-        return new Promise((resolve => {
-            this.emptyResolvers.push(resolve);
-        }));
-    }
-    async waitClosed() {
-        if (this.isClosed()) {
-            return Promise.resolve();
+        try {
+            const value = await executeClassOperation(call.operation, call.arguments);
+            return createExecutePrompt({
+                id: call.id,
+                operation: call.operation,
+                arguments: call.arguments,
+                value
+            });
+        } catch (error) {
+            return createExecutePrompt({
+                id: call.id,
+                operation: call.operation,
+                arguments: call.arguments,
+                value: error instanceof Error ? {
+                    ...error,
+                    name: error.name,
+                    message: error.message
+                } : error
+            });
         }
-        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);
-            }
+async function executeHttpOperation(operation, operationArguments) {
+    const controllerBaseArguments = {
+        connection: operation.controller.connection,
+        application: operation.controller.application,
+        function: operation.function
+    };
+    return operation.controller.execute !== undefined ? operation.controller.execute({
+        ...controllerBaseArguments,
+        arguments: operationArguments
+    }) : HttpLlm.propagate({
+        ...controllerBaseArguments,
+        input: operationArguments
+    });
+}
+
+async function executeClassOperation(operation, operationArguments) {
+    const execute = operation.controller.execute;
+    if (typeof execute === "function") {
+        return await execute({
+            application: operation.controller.application,
+            function: operation.function,
+            arguments: operationArguments
         });
     }
-    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();
+    return execute[operation.function.name](operationArguments);
+}
+
+async function correct(ctx, call, retry, error) {
+    const completionStream = await ctx.request("call", {
+        messages: [ {
+            role: "system",
+            content: AgenticaDefaultPrompt.write(ctx.config)
+        }, ...ctx.histories.map(decodePrompt).flat(), {
+            role: "user",
+            content: ctx.prompt.text
+        }, {
+            role: "system",
+            content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
+        }, {
+            role: "assistant",
+            tool_calls: [ {
+                type: "function",
+                id: call.id,
+                function: {
+                    name: call.operation.name,
+                    arguments: JSON.stringify(call.arguments)
+                }
+            } ]
+        }, {
+            role: "tool",
+            content: typeof error === "string" ? error : JSON.stringify(error),
+            tool_call_id: call.id
+        }, {
+            role: "system",
+            content: [ "You A.I. assistant has composed wrong arguments.", "", "Correct it at the next function calling." ].join("\n")
+        } ],
+        tools: [ {
+            type: "function",
+            function: {
+                name: call.operation.name,
+                description: call.operation.function.description,
+                parameters: call.operation.function.separated !== undefined ? call.operation.function.separated?.llm ?? {
+                    $defs: {},
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: []
+                } : call.operation.function.parameters
+            }
+        } ],
+        tool_choice: "auto",
+        parallel_tool_calls: false
+    });
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+    const toolCall = (completion.choices[0]?.message.tool_calls ?? []).find((tc => tc.type === "function" && tc.function.name === call.operation.name));
+    if (toolCall === undefined) {
+        return null;
     }
+    return propagate(ctx, createCallEvent({
+        id: toolCall.id,
+        operation: call.operation,
+        arguments: JSON.parse(toolCall.function.arguments)
+    }), retry);
 }
 
-async function describe(ctx, histories) {
-    if (histories.length === 0) {
-        return [];
+function fillHttpArguments(props) {
+    if (props.operation.protocol !== "http") {
+        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 route = props.operation.function.route();
+    if (route.body !== null && route.operation().requestBody?.required === true && "body" in props.arguments && isObject(props.operation.function.parameters.$defs, props.operation.function.parameters.properties.body)) {
+        props.arguments.body = {};
+    }
+    if (route.query !== null && "query" in props.arguments && props.arguments.query === undefined) {
+        props.arguments.query = {};
     }
-    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) {
-        return null;
-    }
-    const item = ctx.stack[index];
-    ctx.stack.splice(index, 1);
-    await ctx.dispatch(createCancelEvent({
-        selection: createOperationSelection({
-            operation: item.operation,
-            reason: reference.reason
-        })
-    }));
-    return item;
+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 CONTAINER$1 = {
@@ -1774,325 +1788,213 @@ async function step$1(ctx, operations, retry, failures) {
                 });
                 for (const reference of input.functions) {
                     const operation = await cancelFunction(ctx, reference);
-                    if (operation !== null) {
-                        collection.selections.push(operation);
-                    }
-                }
-                if (collection.selections.length !== 0) {
-                    prompts.push(collection);
-                }
-            }
-        }
-    }
-    return prompts;
-}
-
-function emendMessages$1(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();
-}
-
-async function call(ctx) {
-    const completionStream = await ctx.request("call", {
-        messages: [ {
-            role: "system",
-            content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...ctx.histories.map(decodePrompt).flat(), {
-            role: "user",
-            content: ctx.prompt.text
-        }, {
-            role: "system",
-            content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
-        } ],
-        tools: ctx.stack.map((s => ({
-            type: "function",
-            function: {
-                name: s.operation.name,
-                description: s.operation.function.description,
-                parameters: s.operation.function.separated !== undefined ? s.operation.function.separated.llm ?? {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                    additionalProperties: false,
-                    $defs: {}
-                } : s.operation.function.parameters
-            }
-        }))),
-        tool_choice: "auto",
-        parallel_tool_calls: false
-    });
-    const closures = [];
-    const chunks = await StreamUtil.readAll(completionStream);
-    const completion = ChatGptCompletionMessageUtil.merge(chunks);
-    for (const choice of completion.choices) {
-        for (const tc of choice.message.tool_calls ?? []) {
-            if (tc.type === "function") {
-                const operation = ctx.operations.flat.get(tc.function.name);
-                if (operation === undefined) {
-                    continue;
-                }
-                closures.push((async () => {
-                    const call = createCallEvent({
-                        id: tc.id,
-                        operation,
-                        arguments: JSON.parse(tc.function.arguments)
-                    });
-                    if (call.operation.protocol === "http") {
-                        fillHttpArguments({
-                            operation: call.operation,
-                            arguments: call.arguments
-                        });
-                    }
-                    await ctx.dispatch(call);
-                    const execute = await propagate(ctx, call, 0);
-                    void ctx.dispatch(createExecuteEvent({
-                        id: call.id,
-                        operation: call.operation,
-                        arguments: execute.arguments,
-                        value: execute.value
-                    }));
-                    await cancelFunction(ctx, {
-                        name: call.operation.name,
-                        reason: "completed"
-                    });
-                    void ctx.dispatch(createCancelEvent({
-                        selection: createOperationSelection({
-                            operation: call.operation,
-                            reason: "complete"
-                        })
-                    }));
-                    return [ execute, createCancelPrompt({
-                        id: call.id,
-                        selections: [ createOperationSelection({
-                            operation: call.operation,
-                            reason: "complete"
-                        }) ]
-                    }) ];
-                }));
-            }
-        }
-        if (choice.message.role === "assistant" && choice.message.content !== null && choice.message.content.length > 0) {
-            closures.push((async () => {
-                const value = createTextPrompt({
-                    role: "assistant",
-                    text: choice.message.content
-                });
-                void ctx.dispatch(createTextEvent({
-                    role: "assistant",
-                    get: () => value.text,
-                    done: () => true,
-                    stream: StreamUtil.to(value.text),
-                    join: async () => Promise.resolve(value.text)
-                }));
-                return [ value ];
-            }));
-        }
-    }
-    return (await Promise.all(closures.map((async fn => fn())))).flat();
-}
-
-async function propagate(ctx, call, retry) {
-    if (call.operation.protocol === "http") {
-        const check = call.operation.function.validate(call.arguments);
-        if (check.success === false) {
-            void ctx.dispatch(createValidateEvent({
-                id: call.id,
-                operation: call.operation,
-                result: check
-            }));
-            if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
-                const trial = await correct(ctx, call, retry, check.errors);
-                if (trial !== null) {
-                    return trial;
+                    if (operation !== null) {
+                        collection.selections.push(operation);
+                    }
+                }
+                if (collection.selections.length !== 0) {
+                    prompts.push(collection);
                 }
             }
         }
-        try {
-            const response = await executeHttpOperation(call.operation, call.arguments);
-            const success = ((response.status === 400 || response.status === 404 || response.status === 422) && retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) && typeof response.body) === false;
-            return (success === false ? await correct(ctx, call, retry, response.body) : null) ?? createExecutePrompt({
-                operation: call.operation,
-                id: call.id,
-                arguments: call.arguments,
-                value: response
-            });
-        } catch (error) {
-            return createExecutePrompt({
-                operation: call.operation,
-                id: call.id,
-                arguments: call.arguments,
-                value: {
-                    status: 500,
-                    headers: {},
-                    body: error instanceof Error ? {
-                        ...error,
-                        name: error.name,
-                        message: error.message
-                    } : error
-                }
+    }
+    return prompts;
+}
+
+function emendMessages$1(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();
+}
+
+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
             });
         }
-    } else {
-        const check = call.operation.function.validate(call.arguments);
-        if (check.success === false) {
-            void ctx.dispatch(createValidateEvent({
-                id: call.id,
-                operation: call.operation,
-                result: check
-            }));
-            return (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) ? await correct(ctx, call, retry, check.errors) : null) ?? createExecutePrompt({
-                id: call.id,
-                operation: call.operation,
-                arguments: call.arguments,
-                value: {
-                    name: "TypeGuardError",
-                    message: "Invalid arguments.",
-                    errors: check.errors
-                }
-            });
+    }
+    async dequeue() {
+        if (this.queue.length > 0) {
+            return {
+                value: this.queue.shift(),
+                done: false
+            };
         }
-        try {
-            const value = await executeClassOperation(call.operation, call.arguments);
-            return createExecutePrompt({
-                id: call.id,
-                operation: call.operation,
-                arguments: call.arguments,
-                value
-            });
-        } catch (error) {
-            return createExecutePrompt({
-                id: call.id,
-                operation: call.operation,
-                arguments: call.arguments,
-                value: error instanceof Error ? {
-                    ...error,
-                    name: error.name,
-                    message: error.message
-                } : error
+        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 function executeHttpOperation(operation, operationArguments) {
-    const controllerBaseArguments = {
-        connection: operation.controller.connection,
-        application: operation.controller.application,
-        function: operation.function
-    };
-    return operation.controller.execute !== undefined ? operation.controller.execute({
-        ...controllerBaseArguments,
-        arguments: operationArguments
-    }) : HttpLlm.propagate({
-        ...controllerBaseArguments,
-        input: operationArguments
-    });
-}
-
-async function executeClassOperation(operation, operationArguments) {
-    const execute = operation.controller.execute;
-    if (typeof execute === "function") {
-        return await execute({
-            application: operation.controller.application,
-            function: operation.function,
-            arguments: operationArguments
-        });
+    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);
+        }));
     }
-    return execute[operation.function.name](operationArguments);
 }
 
-async function correct(ctx, call, retry, error) {
-    const completionStream = await ctx.request("call", {
-        messages: [ {
-            role: "system",
-            content: AgenticaDefaultPrompt.write(ctx.config)
-        }, ...ctx.histories.map(decodePrompt).flat(), {
-            role: "user",
-            content: ctx.prompt.text
-        }, {
-            role: "system",
-            content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
-        }, {
-            role: "assistant",
-            tool_calls: [ {
-                type: "function",
-                id: call.id,
-                function: {
-                    name: call.operation.name,
-                    arguments: JSON.stringify(call.arguments)
+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;
                 }
-            } ]
-        }, {
-            role: "tool",
-            content: typeof error === "string" ? error : JSON.stringify(error),
-            tool_call_id: call.id
-        }, {
-            role: "system",
-            content: [ "You A.I. assistant has composed wrong arguments.", "", "Correct it at the next function calling." ].join("\n")
-        } ],
-        tools: [ {
-            type: "function",
-            function: {
-                name: call.operation.name,
-                description: call.operation.function.description,
-                parameters: call.operation.function.separated !== undefined ? call.operation.function.separated?.llm ?? {
-                    $defs: {},
-                    type: "object",
-                    properties: {},
-                    additionalProperties: false,
-                    required: []
-                } : call.operation.function.parameters
+                controller.enqueue(value);
             }
-        } ],
-        tool_choice: "auto",
-        parallel_tool_calls: false
-    });
-    const chunks = await StreamUtil.readAll(completionStream);
-    const completion = ChatGptCompletionMessageUtil.merge(chunks);
-    const toolCall = (completion.choices[0]?.message.tool_calls ?? []).find((tc => tc.type === "function" && tc.function.name === call.operation.name));
-    if (toolCall === undefined) {
-        return null;
+        });
     }
-    return propagate(ctx, createCallEvent({
-        id: toolCall.id,
-        operation: call.operation,
-        arguments: JSON.parse(toolCall.function.arguments)
-    }), retry);
-}
-
-function fillHttpArguments(props) {
-    if (props.operation.protocol !== "http") {
-        return;
+    produce(chunk) {
+        this.queue.enqueue(chunk);
+    }
+    close() {
+        this.queue.close();
+    }
+    done() {
+        return this.queue.done();
     }
-    const route = props.operation.function.route();
-    if (route.body !== null && route.operation().requestBody?.required === true && "body" in props.arguments && isObject(props.operation.function.parameters.$defs, props.operation.function.parameters.properties.body)) {
-        props.arguments.body = {};
+    async waitClosed() {
+        await this.queue.waitClosed();
     }
-    if (route.query !== null && "query" in props.arguments && props.arguments.query === undefined) {
-        props.arguments.query = {};
+    async waitUntilEmpty() {
+        await this.queue.waitUntilEmpty();
     }
 }
 
-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)));
+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
+};
+
 const FUNCTION = {
     functions: [ {
         name: "getApiFunctions",
@@ -3192,6 +3094,10 @@ const FUNCTION = {
                                 type: "string",
                                 enum: [ "object" ]
                             },
+                            properties: {
+                                title: "Properties of the object",
+                                $ref: "#/$defs/RecordstringIChatGptSchema"
+                            },
                             required: {
                                 title: "List of key values of the required properties",
                                 description: 'List of key values of the required properties.\n\nThe `required` means a list of the key values of the required\n{@link properties}. If some property key is not listed in the `required`\nlist, it means that property is optional. Otherwise some property key\nexists in the `required` list, it means that the property must be filled.\n\nBelow is an example of the {@link properties} and `required`.\n\n```typescript\ninterface SomeObject {\n  id: string;\n  email: string;\n  name?: string;\n}\n```\n\nAs you can see, `id` and `email` {@link properties} are {@link required},\nso that they are listed in the `required` list.\n\n```json\n{\n  "type": "object",\n  "properties": {\n    "id": { "type": "string" },\n    "email": { "type": "string" },\n    "name": { "type": "string" }\n  },\n  "required": ["id", "email"]\n}\n```',
@@ -3200,10 +3106,6 @@ const FUNCTION = {
                                     type: "string"
                                 }
                             },
-                            properties: {
-                                title: "Properties of the object",
-                                $ref: "#/$defs/RecordstringIChatGptSchema"
-                            },
                             title: {
                                 title: "Title of the schema",
                                 description: "Title of the schema.",
@@ -3231,7 +3133,7 @@ const FUNCTION = {
                                 additionalProperties: {}
                             }
                         },
-                        required: [ "$defs", "additionalProperties", "type", "required", "properties" ]
+                        required: [ "$defs", "additionalProperties", "type", "properties", "required" ]
                     },
                     separated: {
                         description: "Collection of separated parameters.\n\nFilled only when {@link IHttpLlmApplication.IOptions.separate} is configured.\n\n------------------------------\n\nDescription of the current {@link IHttpLlmFunction.ISeparatedchatgpt} type:\n\n> Collection of separated parameters.",
@@ -3257,6 +3159,10 @@ const FUNCTION = {
                                         type: "string",
                                         enum: [ "object" ]
                                     },
+                                    properties: {
+                                        title: "Properties of the object",
+                                        $ref: "#/$defs/RecordstringIChatGptSchema"
+                                    },
                                     required: {
                                         title: "List of key values of the required properties",
                                         description: 'List of key values of the required properties.\n\nThe `required` means a list of the key values of the required\n{@link properties}. If some property key is not listed in the `required`\nlist, it means that property is optional. Otherwise some property key\nexists in the `required` list, it means that the property must be filled.\n\nBelow is an example of the {@link properties} and `required`.\n\n```typescript\ninterface SomeObject {\n  id: string;\n  email: string;\n  name?: string;\n}\n```\n\nAs you can see, `id` and `email` {@link properties} are {@link required},\nso that they are listed in the `required` list.\n\n```json\n{\n  "type": "object",\n  "properties": {\n    "id": { "type": "string" },\n    "email": { "type": "string" },\n    "name": { "type": "string" }\n  },\n  "required": ["id", "email"]\n}\n```',
@@ -3265,10 +3171,6 @@ const FUNCTION = {
                                             type: "string"
                                         }
                                     },
-                                    properties: {
-                                        title: "Properties of the object",
-                                        $ref: "#/$defs/RecordstringIChatGptSchema"
-                                    },
                                     title: {
                                         title: "Title of the schema",
                                         description: "Title of the schema.",
@@ -3296,7 +3198,7 @@ const FUNCTION = {
                                         additionalProperties: {}
                                     }
                                 },
-                                required: [ "$defs", "additionalProperties", "type", "required", "properties" ]
+                                required: [ "$defs", "additionalProperties", "type", "properties", "required" ]
                             },
                             human: {
                                 title: "Parameters that would be composed by the human",
@@ -3322,6 +3224,10 @@ const FUNCTION = {
                                             type: "string",
                                             enum: [ "object" ]
                                         },
+                                        properties: {
+                                            title: "Properties of the object",
+                                            $ref: "#/$defs/RecordstringIChatGptSchema"
+                                        },
                                         required: {
                                             title: "List of key values of the required properties",
                                             description: 'List of key values of the required properties.\n\nThe `required` means a list of the key values of the required\n{@link properties}. If some property key is not listed in the `required`\nlist, it means that property is optional. Otherwise some property key\nexists in the `required` list, it means that the property must be filled.\n\nBelow is an example of the {@link properties} and `required`.\n\n```typescript\ninterface SomeObject {\n  id: string;\n  email: string;\n  name?: string;\n}\n```\n\nAs you can see, `id` and `email` {@link properties} are {@link required},\nso that they are listed in the `required` list.\n\n```json\n{\n  "type": "object",\n  "properties": {\n    "id": { "type": "string" },\n    "email": { "type": "string" },\n    "name": { "type": "string" }\n  },\n  "required": ["id", "email"]\n}\n```',
@@ -3330,10 +3236,6 @@ const FUNCTION = {
                                                 type: "string"
                                             }
                                         },
-                                        properties: {
-                                            title: "Properties of the object",
-                                            $ref: "#/$defs/RecordstringIChatGptSchema"
-                                        },
                                         title: {
                                             title: "Title of the schema",
                                             description: "Title of the schema.",
@@ -3361,7 +3263,7 @@ const FUNCTION = {
                                             additionalProperties: {}
                                         }
                                     },
-                                    required: [ "$defs", "additionalProperties", "type", "required", "properties" ],
+                                    required: [ "$defs", "additionalProperties", "type", "properties", "required" ],
                                     description: 'Description of the current {@link IChatGptSchema.IParameters} type:\n\n> Type of the function parameters.\n> \n> `IChatGptSchema.IParameters` is a type defining a function\'s parameters\n> as a keyworded object type.\n> \n> It also can be utilized for the structured output metadata.\n\n------------------------------\n\nDescription of the parent {@link IChatGptSchema} type:\n\n> Type schema info of the ChatGPT.\n> \n> `IChatGptSchema` is a type schema info of the ChatGPT function calling.\n> \n> `IChatGptSchema` basically follows the JSON schema definition of the OpenAPI v3.1\n> speciifcation; {@link OpenApiV3_1.IJsonSchema}.\n> \n> However, the `IChatGptSchema` does not follow the entire specification of\n> the OpenAPI v3.1. It has own specific restrictions and definitions. Here is the\n> list of how `IChatGptSchema` is different with the OpenAPI v3.1 JSON schema.\n> \n> - Decompose mixed type: {@link OpenApiV3_1.IJsonSchema.IMixed}\n> - Resolve nullable property: {@link OpenApiV3_1.IJsonSchema.__ISignificant.nullable}\n> - Tuple type is banned: {@link OpenApiV3_1.IJsonSchema.ITuple.prefixItems}\n> - Constant type is banned: {@link OpenApiV3_1.IJsonSchema.IConstant}\n> - Merge {@link OpenApiV3_1.IJsonSchema.IOneOf} to {@link IChatGptSchema.IAnOf}\n> - Merge {@link OpenApiV3_1.IJsonSchema.IAllOf} to {@link IChatGptSchema.IObject}\n> - Merge {@link OpenApiV3_1.IJsonSchema.IRecursiveReference} to {@link IChatGptSchema.IReference}\n> - When {@link IChatGptSchema.IConfig.strict} mode\n>   - Every object properties must be required\n>   - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n> \n> If compare with the {@link OpenApi.IJsonSchema}, the emended JSON schema specification,\n> \n> - {@link IChatGptSchema.IAnyOf} instead of the {@link OpenApi.IJsonSchema.IOneOf}\n> - {@link IChatGptSchema.IParameters.$defs} instead of the {@link OpenApi.IJsonSchema.IComponents.schemas}\n> - {@link IChatGptSchema.IString.enum} instead of the {@link OpenApi.IJsonSchema.IConstant}\n> - {@link IChatGptSchema.additionalProperties} is fixed to `false`\n> - No tuple type {@link OpenApi.IJsonSchema.ITuple} support\n> - When {@link IChatGptSchema.IConfig.strict} mode\n>   - Every object properties must be required\n>   - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n> \n> For reference, if you\'ve composed the `IChatGptSchema` type with the\n> {@link IChatGptSchema.IConfig.reference} `false` option (default is `false`),\n> only the recursived named types would be archived into the\n> {@link IChatGptSchema.IParameters.$defs}, and the others would be ecaped from the\n> {@link IChatGptSchema.IReference} type.\n> \n> Also, OpenAI has banned below constraint properties. Instead, `IChatGptSchema`\n> fills the {@link IChatGptSchema.__IAttribute.description} property with\n> the comment text like `"@format uuid"`.\n> \n> - {@link OpenApi.IJsonSchema.INumber.minimum}\n> - {@link OpenApi.IJsonSchema.INumber.maximum}\n> - {@link OpenApi.IJsonSchema.INumber.multipleOf}\n> - {@link OpenApi.IJsonSchema.IString.minLength}\n> - {@link OpenApi.IJsonSchema.IString.maxLength}\n> - {@link OpenApi.IJsonSchema.IString.format}\n> - {@link OpenApi.IJsonSchema.IString.pattern}\n> - {@link OpenApi.IJsonSchema.IString.contentMediaType}\n> - {@link OpenApi.IJsonSchema.IString.default}\n> - {@link OpenApi.IJsonSchema.IArray.minItems}\n> - {@link OpenApi.IJsonSchema.IArray.maxItems}\n> - {@link OpenApi.IJsonSchema.IArray.unique}\n> \n> Additionally, OpenAI cannot define the `description` property to the\n> {@link IChatGptSchema.IReference} type, and even does not understand\n> the capsulization to the {@link IChatGptSchema.IAnyOf} type.\n> Therefore, the `description` is written to the parent object type,\n> not the reference type.\n> \n> ```json\n> {\n>   "type": "object",\n>   "description": "### Description of {@link something} property.\\n\\n> Hello?",\n>   "properties": {\n>     "something": {\n>       "$ref": "#/$defs/SomeObject"\n>     }\n>   }\n> }\n> ```\n\n### Description of {@link $defs} property:\n\n> Collection of the named types.\n\n### Description of {@link properties} property:\n\n> Properties of the object.\n> \n> The `properties` means a list of key-value pairs of the object\'s\n> regular properties. The key is the name of the regular property,\n> and the value is the type schema info.'
                                 } ]
                             }
@@ -4211,6 +4113,104 @@ function execute(executor) {
     };
 }
 
+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
+};
+
 class Agentica {
     constructor(props) {
         this.props = props;
@@ -4595,7 +4595,7 @@ function assertHttpLlmApplication(props) {
                 if (undefined === value) return true;
                 return "object" === typeof value && null !== value && false === Array.isArray(value) && _iu5(value);
             }));
-            const _io114 = input => Array.isArray(input.type) && input.type.every((elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem)) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples)) && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 0x10000000000000000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 0x10000000000000000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem))) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu5(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu5(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 0x10000000000000000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 0x10000000000000000)) && (undefined === input.required || Array.isArray(input.required) && input.required.every((elem => "string" === typeof elem))) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu5(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io113(input.properties)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io127(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (Array.isArray(input.allOf) && input.allOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && "string" === typeof input.$ref;
+            const _io114 = input => Array.isArray(input.type) && input.type.every((elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem)) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples)) && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 0x10000000000000000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 0x10000000000000000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem))) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu5(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu5(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 0x10000000000000000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 0x10000000000000000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu5(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io113(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every((elem => "string" === typeof elem))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io127(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (Array.isArray(input.allOf) && input.allOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && "string" === typeof input.$ref;
             const _io115 = input => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
             const _io116 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (null === input["default"] || undefined === input["default"] || "boolean" === typeof input["default"]) && (undefined === input["enum"] || Array.isArray(input["enum"]) && input["enum"].every((elem => null === elem || "boolean" === typeof elem))) && "boolean" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
             const _io117 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (null === input["default"] || undefined === input["default"] || "number" === typeof input["default"] && (Math.floor(input["default"]) === input["default"] && -0x8000000000000000 <= input["default"] && input["default"] <= 0x8000000000000000)) && (undefined === input["enum"] || Array.isArray(input["enum"]) && input["enum"].every((elem => null === elem || "number" === typeof elem))) && (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -0x8000000000000000 <= input.minimum && input.minimum <= 0x8000000000000000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -0x8000000000000000 <= input.maximum && input.maximum <= 0x8000000000000000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum && (Math.floor(input.exclusiveMinimum) === input.exclusiveMinimum && -0x8000000000000000 <= input.exclusiveMinimum && input.exclusiveMinimum <= 0x8000000000000000) || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum && (Math.floor(input.exclusiveMaximum) === input.exclusiveMaximum && -0x8000000000000000 <= input.exclusiveMaximum && input.exclusiveMaximum <= 0x8000000000000000) || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 0x10000000000000000 && 0 < input.multipleOf)) && "integer" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
@@ -9660,21 +9660,6 @@ function assertHttpLlmApplication(props) {
                 path: _path + ".maxItems",
                 expected: '((number & Type<"uint64">) | undefined)',
                 value: input.maxItems
-            }, _errorFactory)) && (undefined === input.required || (Array.isArray(input.required) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".required",
-                expected: "(Array<string> | undefined)",
-                value: input.required
-            }, _errorFactory)) && input.required.every(((elem, _index131) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".required[" + _index131 + "]",
-                expected: "string",
-                value: elem
-            }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".required",
-                expected: "(Array<string> | undefined)",
-                value: input.required
             }, _errorFactory)) && ((null !== input.additionalProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".additionalProperties",
@@ -9700,6 +9685,21 @@ function assertHttpLlmApplication(props) {
                 path: _path + ".properties",
                 expected: "(Record<string, OpenApiV3_1.IJsonSchema> | undefined)",
                 value: input.properties
+            }, _errorFactory)) && (undefined === input.required || (Array.isArray(input.required) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".required",
+                expected: "(Array<string> | undefined)",
+                value: input.required
+            }, _errorFactory)) && input.required.every(((elem, _index131) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".required[" + _index131 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".required",
+                expected: "(Array<string> | undefined)",
+                value: input.required
             }, _errorFactory)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".maxProperties",
@@ -13766,7 +13766,7 @@ function validateHttpLlmApplication(props) {
             if (undefined === value) return true;
             return "object" === typeof value && null !== value && false === Array.isArray(value) && _iu5(value);
         }));
-        const _io114 = input => Array.isArray(input.type) && input.type.every((elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem)) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples)) && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 0x10000000000000000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 0x10000000000000000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem))) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu5(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu5(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 0x10000000000000000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 0x10000000000000000)) && (undefined === input.required || Array.isArray(input.required) && input.required.every((elem => "string" === typeof elem))) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu5(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io113(input.properties)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io127(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (Array.isArray(input.allOf) && input.allOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && "string" === typeof input.$ref;
+        const _io114 = input => Array.isArray(input.type) && input.type.every((elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem)) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples)) && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 0x10000000000000000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 0x10000000000000000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem))) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu5(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu5(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 0x10000000000000000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 0x10000000000000000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu5(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io113(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every((elem => "string" === typeof elem))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io127(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && (Array.isArray(input.allOf) && input.allOf.every((elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu5(elem)))) && "string" === typeof input.$ref;
         const _io115 = input => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
         const _io116 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (null === input["default"] || undefined === input["default"] || "boolean" === typeof input["default"]) && (undefined === input["enum"] || Array.isArray(input["enum"]) && input["enum"].every((elem => null === elem || "boolean" === typeof elem))) && "boolean" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
         const _io117 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (null === input["default"] || undefined === input["default"] || "number" === typeof input["default"] && (Math.floor(input["default"]) === input["default"] && -0x8000000000000000 <= input["default"] && input["default"] <= 0x8000000000000000)) && (undefined === input["enum"] || Array.isArray(input["enum"]) && input["enum"].every((elem => null === elem || "number" === typeof elem))) && (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -0x8000000000000000 <= input.minimum && input.minimum <= 0x8000000000000000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -0x8000000000000000 <= input.maximum && input.maximum <= 0x8000000000000000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum && (Math.floor(input.exclusiveMinimum) === input.exclusiveMinimum && -0x8000000000000000 <= input.exclusiveMinimum && input.exclusiveMinimum <= 0x8000000000000000) || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum && (Math.floor(input.exclusiveMaximum) === input.exclusiveMaximum && -0x8000000000000000 <= input.exclusiveMaximum && input.exclusiveMaximum <= 0x8000000000000000) || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 0x10000000000000000 && 0 < input.multipleOf)) && "integer" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.examples || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io58(input.examples));
@@ -17913,18 +17913,6 @@ function validateHttpLlmApplication(props) {
             path: _path + ".maxItems",
             expected: '((number & Type<"uint64">) | undefined)',
             value: input.maxItems
-        }), undefined === input.required || (Array.isArray(input.required) || _report(_exceptionable, {
-            path: _path + ".required",
-            expected: "(Array<string> | undefined)",
-            value: input.required
-        })) && input.required.map(((elem, _index131) => "string" === typeof elem || _report(_exceptionable, {
-            path: _path + ".required[" + _index131 + "]",
-            expected: "string",
-            value: elem
-        }))).every((flag => flag)) || _report(_exceptionable, {
-            path: _path + ".required",
-            expected: "(Array<string> | undefined)",
-            value: input.required
         }), (null !== input.additionalProperties || _report(_exceptionable, {
             path: _path + ".additionalProperties",
             expected: "(OpenApiV3_1.IJsonSchema.IAllOf | OpenApiV3_1.IJsonSchema.IAnyOf | OpenApiV3_1.IJsonSchema.IArray | OpenApiV3_1.IJsonSchema.IBoolean | OpenApiV3_1.IJsonSchema.IConstant | OpenApiV3_1.IJsonSchema.IInteger | OpenApiV3_1.IJsonSchema.IMixed | OpenApiV3_1.IJsonSchema.INull | OpenApiV3_1.IJsonSchema.INumber | OpenApiV3_1.IJsonSchema.IObject | OpenApiV3_1.IJsonSchema.IOneOf | OpenApiV3_1.IJsonSchema.IRecursiveReference | OpenApiV3_1.IJsonSchema.IReference<string> | OpenApiV3_1.IJsonSchema.IString | OpenApiV3_1.IJsonSchema.IUnknown | boolean | undefined)",
@@ -17945,6 +17933,18 @@ function validateHttpLlmApplication(props) {
             path: _path + ".properties",
             expected: "(Record<string, OpenApiV3_1.IJsonSchema> | undefined)",
             value: input.properties
+        }), undefined === input.required || (Array.isArray(input.required) || _report(_exceptionable, {
+            path: _path + ".required",
+            expected: "(Array<string> | undefined)",
+            value: input.required
+        })) && input.required.map(((elem, _index131) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".required[" + _index131 + "]",
+            expected: "string",
+            value: elem
+        }))).every((flag => flag)) || _report(_exceptionable, {
+            path: _path + ".required",
+            expected: "(Array<string> | undefined)",
+            value: input.required
         }), undefined === input.maxProperties || "number" === typeof input.maxProperties || _report(_exceptionable, {
             path: _path + ".maxProperties",
             expected: "(number | undefined)",