@agentica/core 0.10.3 → 0.11.0

package/lib/index.mjs

@@ -1,12 +1,384 @@
+import "typia";
+
+import { v4 } from "uuid";
+
 import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 
 import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
 
 import { HttpLlm, OpenApi, ChatGptTypeChecker } from "@samchon/openapi";
 
-import "typia";
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
 
-import { v4 } from "uuid";
+class AgenticaOperationSelection {
+    constructor(props) {
+        this.operation = props.operation;
+        this.reason = props.reason;
+    }
+    toJSON() {
+        return {
+            operation: this.operation.toJSON(),
+            reason: this.reason
+        };
+    }
+}
+
+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;
+    }
+}
+
+class AgenticaPromptBase {
+    constructor(type) {
+        this.type = type;
+    }
+}
+
+let AgenticaCancelPrompt$1 = class AgenticaCancelPrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("cancel");
+        this.id = props.id;
+        this.selections = props.selections;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            id: this.id,
+            selections: this.selections.map((s => s.toJSON()))
+        };
+    }
+};
+
+class AgenticaDescribePrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("describe");
+        this.executes = props.executes;
+        this.text = props.text;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            executions: this.executes.map((e => e.toJSON())),
+            text: this.text
+        };
+    }
+}
+
+class AgenticaExecutePrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("execute");
+        this.id = props.id;
+        this.operation = props.operation;
+        this.arguments = props.arguments;
+        this.value = props.value;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            id: this.id,
+            operation: this.operation.toJSON(),
+            arguments: this.arguments,
+            value: this.value
+        };
+    }
+}
+
+class AgenticaSelectPrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("select");
+        this.id = props.id;
+        this.selections = props.selections;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            id: this.id,
+            selections: this.selections.map((s => s.toJSON()))
+        };
+    }
+}
+
+class AgenticaTextPrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("text");
+        this.role = props.role;
+        this.text = props.text;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            role: this.role,
+            text: this.text
+        };
+    }
+}
+
+class AgenticaEventBase {
+    constructor(type) {
+        this.type = type;
+    }
+}
+
+class AgenticaCallEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("call");
+        this.id = props.id;
+        this.operation = props.operation;
+        this.arguments = props.arguments;
+    }
+    toJSON() {
+        return {
+            type: "call",
+            id: this.id,
+            operation: this.operation.toJSON(),
+            arguments: this.arguments
+        };
+    }
+}
+
+class AgenticaCancelEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("cancel");
+        this.selection = props.selection;
+    }
+    toJSON() {
+        return {
+            type: "cancel",
+            selection: this.selection.toJSON()
+        };
+    }
+}
+
+class AgenticaDescribeEvent extends AgenticaEventBase {
+    get text() {
+        return this.get_();
+    }
+    get done() {
+        return this.done_();
+    }
+    constructor(props) {
+        super("describe");
+        this.stream = props.stream;
+        this.executes = props.executes;
+        this.done_ = props.done;
+        this.get_ = props.get;
+        this.join_ = props.join;
+    }
+    join() {
+        return this.join_();
+    }
+    toJSON() {
+        return {
+            type: "describe",
+            executes: this.executes.map((e => e.toJSON())),
+            text: this.text,
+            done: this.done
+        };
+    }
+    toPrompt() {
+        return new AgenticaDescribePrompt({
+            executes: this.executes,
+            text: this.text
+        });
+    }
+}
+
+class AgenticaExecuteEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("execute");
+        this.id = props.id;
+        this.operation = props.operation;
+        this.arguments = props.arguments;
+        this.value = props.value;
+    }
+    toJSON() {
+        return {
+            type: "execute",
+            id: this.id,
+            operation: this.operation.toJSON(),
+            arguments: this.arguments,
+            value: this.value
+        };
+    }
+    toPrompt() {
+        return new AgenticaExecutePrompt({
+            id: this.id,
+            operation: this.operation,
+            arguments: this.arguments,
+            value: this.value
+        });
+    }
+}
+
+class AgenticaRequestEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("request");
+        this.source = props.source;
+        this.body = props.body;
+        this.options = props.options;
+    }
+    toJSON() {
+        return {
+            type: "request",
+            source: this.source,
+            body: this.body,
+            options: this.options
+        };
+    }
+}
+
+class AgenticaResponseEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("response");
+        this.source = props.source;
+        this.body = props.body;
+        this.stream = props.stream;
+        this.options = props.options;
+        this.join = props.join;
+    }
+}
+
+class AgenticaSelectEvent extends AgenticaEventBase {
+    constructor(props) {
+        super("select");
+        this.selection = props.selection;
+    }
+    toJSON() {
+        return {
+            type: "select",
+            selection: this.selection.toJSON()
+        };
+    }
+    toPrompt() {
+        return new AgenticaSelectPrompt({
+            id: v4(),
+            selections: [ this.selection ]
+        });
+    }
+}
+
+class AgenticaTextEvent extends AgenticaEventBase {
+    get text() {
+        return this.get_();
+    }
+    get done() {
+        return this.done_();
+    }
+    constructor(props) {
+        super("text");
+        this.role = props.role;
+        this.stream = props.stream;
+        this.done_ = props.done;
+        this.get_ = props.get;
+        this.join_ = props.join;
+    }
+    join() {
+        return this.join_();
+    }
+    toJSON() {
+        return {
+            type: "text",
+            role: this.role,
+            text: this.text,
+            done: this.done
+        };
+    }
+    toPrompt() {
+        return new AgenticaTextPrompt({
+            role: this.role,
+            text: this.text
+        });
+    }
+}
 
 const createHttpLlmApplication = props => {
     const inspect = (() => {
@@ -7549,6 +7921,21 @@ const createHttpLlmApplication = props => {
     };
 };
 
+class AgenticaCancelPrompt extends AgenticaPromptBase {
+    constructor(props) {
+        super("cancel");
+        this.id = props.id;
+        this.selections = props.selections;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            id: this.id,
+            selections: this.selections.map((s => s.toJSON()))
+        };
+    }
+}
+
 var AgenticaConstant;
 
 (function(AgenticaConstant) {
@@ -7600,26 +7987,616 @@ const isNode = new Singleton((() => {
     return typeof global === "object" && isObject(global) && isObject(global.process) && isObject(global.process.versions) && typeof global.process.versions.node !== "undefined";
 }));
 
-var AgenticaPromptFactory;
+var StreamUtil;
 
-(function(AgenticaPromptFactory) {
-    AgenticaPromptFactory.execute = props => ({
-        ...props,
-        toJSON: () => ({
-            ...props,
-            controller: props.controller.name,
-            function: props.function.name
-        })
+(function(StreamUtil) {
+    StreamUtil.readAll = async stream => {
+        const reader = stream.getReader();
+        const result = [];
+        while (true) {
+            const {done, value} = await reader.read();
+            if (done) break;
+            result.push(value);
+        }
+        return result;
+    };
+    StreamUtil.reduce = async (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;
+    };
+    StreamUtil.to = value => {
+        const stream = new ReadableStream({
+            start: controller => {
+                controller.enqueue(value);
+                controller.close();
+            }
+        });
+        return stream;
+    };
+    StreamUtil.transform = (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();
+                }
+            }
+        });
+    };
+})(StreamUtil || (StreamUtil = {}));
+
+var ByteArrayUtil;
+
+(function(ByteArrayUtil) {
+    ByteArrayUtil.toUtf8 = byteArray => (new TextDecoder).decode(byteArray);
+})(ByteArrayUtil || (ByteArrayUtil = {}));
+
+var ChatGptUsageAggregator;
+
+(function(ChatGptUsageAggregator) {
+    ChatGptUsageAggregator.sumCompletionTokenDetail = (x, y) => ({
+        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)
     });
-    AgenticaPromptFactory.selection = props => ({
-        ...props,
-        toJSON: () => ({
-            ...props,
-            controller: props.controller.name,
-            function: props.function.name
+    ChatGptUsageAggregator.sumPromptTokenDetail = (x, y) => ({
+        audio_tokens: (x.audio_tokens ?? 0) + (y.audio_tokens ?? 0),
+        cached_tokens: (x.cached_tokens ?? 0) + (y.cached_tokens ?? 0)
+    });
+    ChatGptUsageAggregator.sum = (x, y) => ({
+        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: ChatGptUsageAggregator.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: ChatGptUsageAggregator.sumPromptTokenDetail(x.prompt_tokens_details ?? {
+            audio_tokens: 0,
+            cached_tokens: 0
+        }, y.prompt_tokens_details ?? {
+            audio_tokens: 0,
+            cached_tokens: 0
         })
     });
-})(AgenticaPromptFactory || (AgenticaPromptFactory = {}));
+})(ChatGptUsageAggregator || (ChatGptUsageAggregator = {}));
+
+var ChatGptCompletionMessageUtil;
+
+(function(ChatGptCompletionMessageUtil) {
+    ChatGptCompletionMessageUtil.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",
+                        value: input
+                    }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+                        method: "json.assertParse",
+                        path: _path + "",
+                        expected: "ChatCompletionChunk",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+            return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
+        })()(str);
+    };
+    ChatGptCompletionMessageUtil.accumulate = (origin, chunk) => {
+        const choices = origin.choices;
+        chunk.choices.forEach((choice => {
+            const accChoice = choices[choice.index];
+            if (accChoice) {
+                choices[choice.index] = ChatGptCompletionMessageUtil.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 ? 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) {
+                return origin.usage;
+            }
+            if (!origin.usage) {
+                return chunk.usage;
+            }
+            return ChatGptUsageAggregator.sum(origin.usage, chunk.usage);
+        })();
+        return {
+            ...origin,
+            choices,
+            usage
+        };
+    };
+    ChatGptCompletionMessageUtil.merge = chunks => {
+        const firstChunk = chunks[0];
+        if (!firstChunk) throw new Error("No chunks received");
+        return chunks.reduce(ChatGptCompletionMessageUtil.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
+        });
+    };
+    ChatGptCompletionMessageUtil.mergeChoice = (acc, cur) => {
+        var _a;
+        if (!acc.finish_reason && cur.finish_reason) {
+            acc.finish_reason = cur.finish_reason;
+        }
+        if (!acc.logprobs && cur.logprobs) {
+            acc.logprobs = cur.logprobs;
+        }
+        if (cur.delta.content) {
+            if (!acc.message.content) {
+                acc.message.content = cur.delta.content;
+            } else {
+                acc.message.content += cur.delta.content;
+            }
+        }
+        if (cur.delta.refusal) {
+            if (!acc.message.refusal) {
+                acc.message.refusal = cur.delta.refusal;
+            } else {
+                acc.message.refusal += cur.delta.refusal;
+            }
+        }
+        if (cur.delta.tool_calls) {
+            (_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) {
+                    toolCalls[toolCall.index] = ChatGptCompletionMessageUtil.mergeToolCalls(existingToolCall, toolCall);
+                    return;
+                }
+                toolCalls[toolCall.index] = {
+                    id: toolCall.id ?? "",
+                    type: "function",
+                    function: {
+                        name: toolCall.function?.name ?? "",
+                        arguments: toolCall.function?.arguments ?? ""
+                    }
+                };
+            }));
+        }
+        return acc;
+    };
+    ChatGptCompletionMessageUtil.mergeToolCalls = (acc, cur) => {
+        if (cur.function) {
+            acc.function.arguments += cur.function.arguments ?? "";
+            acc.function.name += cur.function.name ?? "";
+        }
+        acc.id += cur.id ?? "";
+        return acc;
+    };
+})(ChatGptCompletionMessageUtil || (ChatGptCompletionMessageUtil = {}));
 
 var ChatGptHistoryDecoder;
 
@@ -7636,9 +8613,9 @@ var ChatGptHistoryDecoder;
                 function: {
                     name: `${history.type}Functions`,
                     arguments: JSON.stringify({
-                        functions: history.operations.map((t => ({
-                            name: t.function.name,
-                            reason: t.reason
+                        functions: history.selections.map((s => ({
+                            name: s.operation.function.name,
+                            reason: s.reason
                         })))
                     })
                 }
@@ -7654,7 +8631,7 @@ var ChatGptHistoryDecoder;
                 type: "function",
                 id: history.id,
                 function: {
-                    name: history.function.name,
+                    name: history.operation.name,
                     arguments: JSON.stringify(history.arguments)
                 }
             } ]
@@ -7663,16 +8640,16 @@ var ChatGptHistoryDecoder;
             tool_call_id: history.id,
             content: JSON.stringify({
                 function: {
-                    protocol: history.protocol,
-                    description: history.function.description,
-                    parameters: history.function.parameters,
-                    output: history.function.output,
-                    ...history.protocol === "http" ? {
-                        method: history.function.method,
-                        path: history.function.path
+                    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.protocol === "http" ? {
+                ...history.operation.protocol === "http" ? {
                     status: history.value.status,
                     data: history.value.body
                 } : {
@@ -7697,41 +8674,35 @@ var ChatGptCancelFunctionAgent;
                 events.push(e);
             }
         }, operations, 0))));
-        if (stacks.every((s => s.length === 0))) return prompts[0]; else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) return step(ctx, stacks.flat().map((s => ctx.operations.group.get(s.controller.name).get(s.function.name))), 0);
-        const collection = {
+        if (stacks.every((s => s.length === 0))) return prompts[0]; else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) return step(ctx, stacks.flat().map((s => ctx.operations.group.get(s.operation.controller.name).get(s.operation.function.name))), 0);
+        const collection = new AgenticaCancelPrompt({
             id: v4(),
-            type: "cancel",
-            operations: []
-        };
+            selections: []
+        });
         for (const e of events) if (e.type === "select") {
-            collection.operations.push(AgenticaPromptFactory.selection({
-                protocol: e.operation.protocol,
-                controller: e.operation.controller,
-                function: e.operation.function,
-                reason: e.reason,
-                name: e.operation.name
-            }));
+            collection.selections.push(e.selection);
             await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
-                name: e.operation.name,
-                reason: e.reason
+                name: e.selection.operation.name,
+                reason: e.selection.reason
             });
         }
         return [ collection ];
     };
     ChatGptCancelFunctionAgent.cancelFunction = async (ctx, reference) => {
-        const index = ctx.stack.findIndex((item => item.name === reference.name));
+        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({
-            type: "cancel",
-            operation: item,
-            reason: reference.reason
-        });
+        await ctx.dispatch(new AgenticaCancelEvent({
+            selection: new AgenticaOperationSelection({
+                operation: item.operation,
+                reason: reference.reason
+            })
+        }));
         return item;
     };
     const step = async (ctx, operations, retry, failures) => {
-        const completion = await ctx.request("cancel", {
+        const completionStream = await ctx.request("cancel", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -7775,6 +8746,8 @@ var ChatGptCancelFunctionAgent;
             tool_choice: "auto",
             parallel_tool_calls: true
         });
+        const chunks = await StreamUtil.readAll(completionStream);
+        const completion = ChatGptCompletionMessageUtil.merge(chunks);
         if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
             const failures = [];
             for (const choice of completion.choices) for (const tc of choice.message.tool_calls ?? []) {
@@ -7859,16 +8832,15 @@ var ChatGptCancelFunctionAgent;
                     const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
                     return input => "object" === typeof input && null !== input && _io0(input);
                 })()(input) === false) continue; else if (tc.function.name === "cancelFunctions") {
-                    const collection = {
+                    const collection = new AgenticaCancelPrompt({
                         id: tc.id,
-                        type: "cancel",
-                        operations: []
-                    };
+                        selections: []
+                    });
                     for (const reference of input.functions) {
                         const operation = await ChatGptCancelFunctionAgent.cancelFunction(ctx, reference);
-                        if (operation !== null) collection.operations.push(operation);
+                        if (operation !== null) collection.selections.push(operation);
                     }
-                    if (collection.operations.length !== 0) prompts.push(collection);
+                    if (collection.selections.length !== 0) prompts.push(collection);
                 }
             }
         }
@@ -7995,7 +8967,7 @@ var ChatGptCallFunctionAgent;
 
 (function(ChatGptCallFunctionAgent) {
     ChatGptCallFunctionAgent.execute = async ctx => {
-        const completion = await ctx.request("call", {
+        const completionStream = await ctx.request("call", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -8006,76 +8978,81 @@ var ChatGptCallFunctionAgent;
                 role: "system",
                 content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
             } ],
-            tools: ctx.stack.map((op => ({
+            tools: ctx.stack.map((s => ({
                 type: "function",
                 function: {
-                    name: op.name,
-                    description: op.function.description,
-                    parameters: op.function.separated ? op.function.separated.llm ?? {
+                    name: s.operation.name,
+                    description: s.operation.function.description,
+                    parameters: s.operation.function.separated ? s.operation.function.separated.llm ?? {
                         type: "object",
                         properties: {},
                         required: [],
                         additionalProperties: false,
                         $defs: {}
-                    } : op.function.parameters
+                    } : 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 = {
-                            type: "call",
+                        const call = new AgenticaCallEvent({
                             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);
-                        await ctx.dispatch({
-                            type: "execute",
+                        await ctx.dispatch(new AgenticaExecuteEvent({
                             id: call.id,
                             operation: call.operation,
                             arguments: execute.arguments,
                             value: execute.value
-                        });
+                        }));
                         await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
                             name: call.operation.name,
                             reason: "completed"
                         });
-                        await ctx.dispatch({
-                            type: "cancel",
-                            operation: call.operation,
-                            reason: "complete"
-                        });
-                        return [ execute, {
-                            type: "cancel",
+                        await ctx.dispatch(new AgenticaCancelEvent({
+                            selection: new AgenticaOperationSelection({
+                                operation: call.operation,
+                                reason: "complete"
+                            })
+                        }));
+                        return [ execute, new AgenticaCancelPrompt({
                             id: call.id,
-                            operations: [ AgenticaPromptFactory.selection({
-                                ...call.operation,
+                            selections: [ new AgenticaOperationSelection({
+                                operation: call.operation,
                                 reason: "complete"
                             }) ]
-                        } ];
+                        }) ];
                     }));
                 }
             }
             if (choice.message.role === "assistant" && !!choice.message.content?.length) closures.push((async () => {
-                const value = {
-                    type: "text",
+                const value = new AgenticaTextPrompt({
                     role: "assistant",
                     text: choice.message.content
-                };
-                await ctx.dispatch(value);
+                });
+                await ctx.dispatch(new AgenticaTextEvent({
+                    role: "assistant",
+                    get: () => value.text,
+                    done: () => true,
+                    stream: StreamUtil.to(value.text),
+                    join: () => Promise.resolve(value.text)
+                }));
                 return [ value ];
             }));
         }
@@ -8101,24 +9078,16 @@ var ChatGptCallFunctionAgent;
                     input: 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) ?? await AgenticaPromptFactory.execute({
-                    type: "execute",
-                    protocol: "http",
-                    controller: call.operation.controller,
-                    function: call.operation.function,
+                return (success === false ? await correct(ctx, call, retry, response.body) : null) ?? new AgenticaExecutePrompt({
+                    operation: call.operation,
                     id: call.id,
-                    name: call.operation.name,
                     arguments: call.arguments,
                     value: response
                 });
             } catch (error) {
-                return AgenticaPromptFactory.execute({
-                    type: "execute",
-                    protocol: "http",
-                    controller: call.operation.controller,
-                    function: call.operation.function,
+                return new AgenticaExecutePrompt({
+                    operation: call.operation,
                     id: call.id,
-                    name: call.operation.name,
                     arguments: call.arguments,
                     value: {
                         status: 500,
@@ -8133,13 +9102,9 @@ var ChatGptCallFunctionAgent;
             }
         } else {
             const check = call.operation.function.validate(call.arguments);
-            if (check.success === false) return (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) ? await correct(ctx, call, retry, check.errors) : null) ?? AgenticaPromptFactory.execute({
-                type: "execute",
-                protocol: "class",
-                controller: call.operation.controller,
-                function: call.operation.function,
+            if (check.success === false) return (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY) ? await correct(ctx, call, retry, check.errors) : null) ?? new AgenticaExecutePrompt({
                 id: call.id,
-                name: call.operation.name,
+                operation: call.operation,
                 arguments: call.arguments,
                 value: {
                     name: "TypeGuardError",
@@ -8153,24 +9118,16 @@ var ChatGptCallFunctionAgent;
                     function: call.operation.function,
                     arguments: call.arguments
                 }) : await call.operation.controller.execute[call.operation.function.name](call.arguments);
-                return AgenticaPromptFactory.execute({
-                    type: "execute",
-                    protocol: "class",
-                    controller: call.operation.controller,
-                    function: call.operation.function,
+                return new AgenticaExecutePrompt({
                     id: call.id,
-                    name: call.operation.name,
+                    operation: call.operation,
                     arguments: call.arguments,
                     value
                 });
             } catch (error) {
-                return AgenticaPromptFactory.execute({
-                    type: "execute",
-                    protocol: "class",
-                    controller: call.operation.controller,
-                    function: call.operation.function,
+                return new AgenticaExecutePrompt({
                     id: call.id,
-                    name: call.operation.name,
+                    operation: call.operation,
                     arguments: call.arguments,
                     value: error instanceof Error ? {
                         ...error,
@@ -8182,7 +9139,7 @@ var ChatGptCallFunctionAgent;
         }
     };
     const correct = async (ctx, call, retry, error) => {
-        const completion = await ctx.request("call", {
+        const completionStream = await ctx.request("call", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -8227,14 +9184,15 @@ var ChatGptCallFunctionAgent;
             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, {
+        return propagate(ctx, new AgenticaCallEvent({
             id: toolCall.id,
-            type: "call",
             operation: call.operation,
             arguments: JSON.parse(toolCall.function.arguments)
-        }, retry);
+        }), retry);
     };
     const fillHttpArguments = props => {
         if (props.operation.protocol !== "http") return;
@@ -8245,12 +9203,89 @@ var ChatGptCallFunctionAgent;
     const isObject = ($defs, schema) => ChatGptTypeChecker.isObject(schema) || ChatGptTypeChecker.isReference(schema) && isObject($defs, $defs[schema.$ref.split("/").at(-1)]) || ChatGptTypeChecker.isAnyOf(schema) && schema.anyOf.every((schema => isObject($defs, schema)));
 })(ChatGptCallFunctionAgent || (ChatGptCallFunctionAgent = {}));
 
+var MPSCUtil;
+
+(function(MPSCUtil) {
+    MPSCUtil.create = () => {
+        const queue = new AsyncQueue;
+        const consumer = new ReadableStream({
+            async pull(controller) {
+                const {value, done} = await queue.dequeue();
+                if (done) {
+                    controller.close();
+                } else {
+                    controller.enqueue(value);
+                }
+            }
+        });
+        return {
+            consumer,
+            produce: chunk => queue.enqueue(chunk),
+            close: () => queue.close(),
+            done: () => queue.done(),
+            waitClose: () => queue.waitClose()
+        };
+    };
+    class AsyncQueue {
+        constructor() {
+            this.queue = [];
+            this.resolvers = [];
+            this.closeResolvers = [];
+            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) return {
+                value: undefined,
+                done: true
+            };
+            return new Promise((resolve => this.resolvers.push(resolve)));
+        }
+        done() {
+            return this.closed;
+        }
+        close() {
+            this.closed = true;
+            while (this.resolvers.length > 0) {
+                this.resolvers.shift()?.({
+                    value: undefined,
+                    done: true
+                });
+            }
+            this.closeResolvers.forEach((resolve => resolve()));
+        }
+        waitClose() {
+            if (this.closed) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve => {
+                this.closeResolvers.push(resolve);
+            }));
+        }
+    }
+    MPSCUtil.AsyncQueue = AsyncQueue;
+})(MPSCUtil || (MPSCUtil = {}));
+
 var ChatGptDescribeFunctionAgent;
 
 (function(ChatGptDescribeFunctionAgent) {
     ChatGptDescribeFunctionAgent.execute = async (ctx, histories) => {
         if (histories.length === 0) return [];
-        const completion = await ctx.request("describe", {
+        const completionStream = await ctx.request("describe", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -8259,12 +9294,57 @@ var ChatGptDescribeFunctionAgent;
                 content: ctx.config?.systemPrompt?.describe?.(histories) ?? AgenticaSystemPrompt.DESCRIBE
             } ]
         });
-        const descriptions = completion.choices.map((choice => choice.message.role === "assistant" && !!choice.message.content?.length ? choice.message.content : null)).filter((str => str !== null)).map((content => ({
-            type: "describe",
-            executions: histories,
+        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) {
+                        describeContext[choice.index].close();
+                        continue;
+                    }
+                    if (!choice.delta.content) {
+                        continue;
+                    }
+                    if (describeContext[choice.index]) {
+                        describeContext[choice.index].content += choice.delta.content;
+                        describeContext[choice.index].produce(choice.delta.content);
+                        continue;
+                    }
+                    const {consumer, produce, close, waitClose, done} = MPSCUtil.create();
+                    describeContext[choice.index] = {
+                        content: choice.delta.content,
+                        consumer,
+                        produce,
+                        close,
+                        waitClose,
+                        done
+                    };
+                    produce(choice.delta.content);
+                    void ctx.dispatch(new AgenticaDescribeEvent({
+                        executes: histories,
+                        stream: consumer,
+                        done,
+                        get: () => describeContext[choice.index]?.content ?? "",
+                        join: async () => {
+                            await waitClose();
+                            return describeContext[choice.index].content;
+                        }
+                    }));
+                }
+            };
+            if (acc.object === "chat.completion.chunk") {
+                registerContext([ acc, chunk ].flatMap((acc => acc.choices)));
+                return ChatGptCompletionMessageUtil.merge([ acc, chunk ]);
+            }
+            registerContext(chunk.choices);
+            return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
+        }));
+        if (!completion) throw new Error("No completion received");
+        const descriptions = completion.choices.map((choice => choice.message.role === "assistant" && !!choice.message.content?.length ? choice.message.content : null)).filter((str => str !== null)).map((content => new AgenticaDescribePrompt({
+            executes: histories,
             text: content
         })));
-        for (const describe of descriptions) await ctx.dispatch(describe);
         return descriptions;
     };
 })(ChatGptDescribeFunctionAgent || (ChatGptDescribeFunctionAgent = {}));
@@ -8273,7 +9353,7 @@ var ChatGptInitializeFunctionAgent;
 
 (function(ChatGptInitializeFunctionAgent) {
     ChatGptInitializeFunctionAgent.execute = async ctx => {
-        const completion = await ctx.request("initialize", {
+        const completionStream = await ctx.request("initialize", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -8295,13 +9375,16 @@ var ChatGptInitializeFunctionAgent;
             tool_choice: "auto",
             parallel_tool_calls: false
         });
+        const chunks = await StreamUtil.readAll(completionStream);
+        const completion = ChatGptCompletionMessageUtil.merge(chunks);
         const prompts = [];
         for (const choice of completion.choices) {
-            if (choice.message.role === "assistant" && !!choice.message.content?.length) prompts.push({
-                type: "text",
-                role: "assistant",
-                text: choice.message.content
-            });
+            if (choice.message.role === "assistant" && !!choice.message.content?.length) {
+                prompts.push(new AgenticaTextPrompt({
+                    role: "assistant",
+                    text: choice.message.content
+                }));
+            }
         }
         if (completion.choices.some((c => !!c.message.tool_calls?.some((tc => tc.type === "function" && tc.function.name === FUNCTION.name))))) await ctx.initialize();
         return prompts;
@@ -9959,29 +11042,22 @@ var ChatGptSelectFunctionAgent;
                 events.push(e);
             }
         }, operations, 0))));
-        if (stacks.every((s => s.length === 0))) return prompts[0]; else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) return step(ctx, stacks.flat().map((s => ctx.operations.group.get(s.controller.name).get(s.function.name))), 0);
-        const collection = {
+        if (stacks.every((s => s.length === 0))) return prompts[0]; else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) return step(ctx, stacks.flat().map((s => ctx.operations.group.get(s.operation.controller.name).get(s.operation.function.name))), 0);
+        const collection = new AgenticaSelectPrompt({
             id: v4(),
-            type: "select",
-            operations: []
-        };
+            selections: []
+        });
         for (const e of events) if (e.type === "select") {
-            collection.operations.push(AgenticaPromptFactory.selection({
-                protocol: e.operation.protocol,
-                controller: e.operation.controller,
-                function: e.operation.function,
-                reason: e.reason,
-                name: e.operation.name
-            }));
+            collection.selections.push(e.selection);
             await selectFunction(ctx, {
-                name: e.operation.name,
-                reason: e.reason
+                name: e.selection.operation.name,
+                reason: e.selection.reason
             });
         }
         return [ collection ];
     };
     const step = async (ctx, operations, retry, failures) => {
-        const completion = await ctx.request("select", {
+        const completionStream = await ctx.request("select", {
             messages: [ {
                 role: "system",
                 content: AgenticaDefaultPrompt.write(ctx.config)
@@ -10025,6 +11101,8 @@ var ChatGptSelectFunctionAgent;
             tool_choice: "auto",
             parallel_tool_calls: false
         });
+        const chunks = await StreamUtil.readAll(completionStream);
+        const completion = ChatGptCompletionMessageUtil.merge(chunks);
         if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
             const failures = [];
             for (const choice of completion.choices) for (const tc of choice.message.tool_calls ?? []) {
@@ -10109,32 +11187,33 @@ var ChatGptSelectFunctionAgent;
                     const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
                     return input => "object" === typeof input && null !== input && _io0(input);
                 })()(input) === false) continue; else if (tc.function.name === "selectFunctions") {
-                    const collection = {
+                    const collection = new AgenticaSelectPrompt({
                         id: tc.id,
-                        type: "select",
-                        operations: []
-                    };
+                        selections: []
+                    });
                     for (const reference of input.functions) {
                         const operation = await selectFunction(ctx, reference);
-                        if (operation !== null) collection.operations.push(AgenticaPromptFactory.selection({
-                            protocol: operation.protocol,
-                            controller: operation.controller,
-                            function: operation.function,
-                            name: operation.name,
+                        if (operation !== null) collection.selections.push(new AgenticaOperationSelection({
+                            operation,
                             reason: reference.reason
                         }));
                     }
-                    if (collection.operations.length !== 0) prompts.push(collection);
+                    if (collection.selections.length !== 0) prompts.push(collection);
                 }
             }
             if (choice.message.role === "assistant" && !!choice.message.content?.length) {
-                const text = {
-                    type: "text",
+                const text = new AgenticaTextPrompt({
                     role: "assistant",
                     text: choice.message.content
-                };
+                });
                 prompts.push(text);
-                await ctx.dispatch(text);
+                await ctx.dispatch(new AgenticaTextEvent({
+                    role: "assistant",
+                    stream: StreamUtil.to(text.text),
+                    join: () => Promise.resolve(text.text),
+                    done: () => true,
+                    get: () => text.text
+                }));
             }
         }
         return prompts;
@@ -10142,18 +11221,14 @@ var ChatGptSelectFunctionAgent;
     const selectFunction = async (ctx, reference) => {
         const operation = ctx.operations.flat.get(reference.name);
         if (operation === undefined) return null;
-        ctx.stack.push(AgenticaPromptFactory.selection({
-            protocol: operation.protocol,
-            controller: operation.controller,
-            function: operation.function,
-            name: reference.name,
+        const selection = new AgenticaOperationSelection({
+            operation,
             reason: reference.reason
-        }));
-        await ctx.dispatch({
-            type: "select",
-            reason: reference.reason,
-            operation
         });
+        ctx.stack.push(selection);
+        void ctx.dispatch(new AgenticaSelectEvent({
+            selection
+        }));
         return operation;
     };
     const emendMessages = failures => failures.map((f => [ {
@@ -10293,7 +11368,7 @@ var ChatGptAgent;
             const executes = prompts.filter((prompt => prompt.type === "execute"));
             for (const e of executes) await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
                 reason: "completed",
-                name: e.function.name
+                name: e.operation.name
             });
             histories.push(...await (executor?.describe ?? ChatGptDescribeFunctionAgent.execute)(ctx, executes));
             if (executes.length === 0 || ctx.stack.length === 0) break;
@@ -10302,6 +11377,43 @@ var ChatGptAgent;
     };
 })(ChatGptAgent || (ChatGptAgent = {}));
 
+var AgenticaTokenUsageAggregator;
+
+(function(AgenticaTokenUsageAggregator) {
+    AgenticaTokenUsageAggregator.aggregate = props => {
+        if (!props.completionUsage) return;
+        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.total_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));
+    };
+})(AgenticaTokenUsageAggregator || (AgenticaTokenUsageAggregator = {}));
+
+class AgenticaInitializeEvent extends AgenticaEventBase {
+    constructor() {
+        super("initialize");
+    }
+    toJSON() {
+        return {
+            type: "initialize"
+        };
+    }
+}
+
 const __map_take = (dict, key, generator) => {
     const oldbie = dict.get(key);
     if (oldbie) return oldbie;
@@ -10323,12 +11435,24 @@ var AgenticaOperationComposer;
             protocol: "http",
             controller,
             function: func,
-            name: naming(func.name, ci)
+            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)
+            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 && array.length > props.config.capacity ? divideOperations({
             array,
@@ -10359,122 +11483,67 @@ var AgenticaPromptTransformer;
 
 (function(AgenticaPromptTransformer) {
     AgenticaPromptTransformer.transform = props => {
-        if (props.input.type === "text") return props.input; else if (props.input.type === "select" || props.input.type === "cancel") return {
-            ...props.input,
-            operations: props.input.operations.map((func => AgenticaPromptFactory.selection({
-                ...findOperation({
-                    operations: props.operations,
-                    input: func
-                }),
-                reason: func.reason
-            })))
-        }; else if (props.input.type === "execute") return transformExecute({
+        if (props.prompt.type === "text") return AgenticaPromptTransformer.transformText({
+            prompt: props.prompt
+        }); else if (props.prompt.type === "select") return AgenticaPromptTransformer.transformSelect({
             operations: props.operations,
-            input: props.input
-        });
-        return {
-            type: "describe",
-            text: props.input.text,
-            executions: props.input.executions.map((next => transformExecute({
-                operations: props.operations,
-                input: next
-            })))
-        };
-    };
-    const transformExecute = props => {
-        const operation = findOperation({
+            prompt: props.prompt
+        }); else if (props.prompt.type === "cancel") return AgenticaPromptTransformer.transformCancel({
             operations: props.operations,
-            input: props.input
-        });
-        return AgenticaPromptFactory.execute({
-            type: "execute",
-            protocol: operation.protocol,
-            controller: operation.controller,
-            function: operation.function,
-            id: props.input.id,
-            name: props.input.name,
-            arguments: props.input.arguments,
-            value: props.input.value
+            prompt: props.prompt
+        }); else if (props.prompt.type === "execute") return AgenticaPromptTransformer.transformExecute({
+            operations: props.operations,
+            prompt: props.prompt
+        }); else if (props.prompt.type === "describe") return AgenticaPromptTransformer.transformDescribe({
+            operations: props.operations,
+            prompt: props.prompt
         });
+        throw new Error("Invalid prompt type.");
     };
-    const 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;
-    };
+    AgenticaPromptTransformer.transformText = props => new AgenticaTextPrompt(props.prompt);
+    AgenticaPromptTransformer.transformSelect = props => new AgenticaSelectPrompt({
+        id: props.prompt.id,
+        selections: props.prompt.selections.map((select => new AgenticaOperationSelection({
+            operation: findOperation({
+                operations: props.operations,
+                input: select.operation
+            }),
+            reason: select.reason
+        })))
+    });
+    AgenticaPromptTransformer.transformCancel = props => new AgenticaCancelPrompt$1({
+        id: props.prompt.id,
+        selections: props.prompt.selections.map((select => new AgenticaOperationSelection({
+            operation: findOperation({
+                operations: props.operations,
+                input: select.operation
+            }),
+            reason: select.reason
+        })))
+    });
+    AgenticaPromptTransformer.transformExecute = props => new AgenticaExecutePrompt({
+        id: props.prompt.id,
+        operation: findOperation({
+            operations: props.operations,
+            input: props.prompt.operation
+        }),
+        arguments: props.prompt.arguments,
+        value: props.prompt.value
+    });
+    AgenticaPromptTransformer.transformDescribe = props => new AgenticaDescribePrompt({
+        text: props.prompt.text,
+        executes: props.prompt.executions.map((next => AgenticaPromptTransformer.transformExecute({
+            operations: props.operations,
+            prompt: next
+        })))
+    });
 })(AgenticaPromptTransformer || (AgenticaPromptTransformer = {}));
 
-var AgenticaTokenUsageAggregator;
-
-(function(AgenticaTokenUsageAggregator) {
-    AgenticaTokenUsageAggregator.aggregate = props => {
-        if (!props.completion.usage) return;
-        const component = props.usage[props.kind];
-        component.total += props.completion.usage.total_tokens;
-        component.input.total += props.completion.usage.prompt_tokens;
-        props.completion.usage.prompt_tokens_details?.audio_tokens ?? 0;
-        component.input.cached += props.completion.usage.prompt_tokens_details?.cached_tokens ?? 0;
-        component.output.total += props.completion.usage.total_tokens;
-        component.output.accepted_prediction += props.completion.usage.completion_tokens_details?.accepted_prediction_tokens ?? 0;
-        component.output.reasoning += props.completion.usage.completion_tokens_details?.reasoning_tokens ?? 0;
-        component.output.rejected_prediction += props.completion.usage.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));
-    };
-    AgenticaTokenUsageAggregator.plus = (x, y) => {
-        const component = (a, b) => ({
-            total: a.total + b.total,
-            input: {
-                total: a.input.total + b.input.total,
-                cached: a.input.cached + b.input.cached
-            },
-            output: {
-                total: a.output.total + b.output.total,
-                reasoning: a.output.reasoning + b.output.reasoning,
-                accepted_prediction: a.output.accepted_prediction + b.output.accepted_prediction,
-                rejected_prediction: a.output.rejected_prediction + b.output.rejected_prediction
-            }
-        });
-        return {
-            aggregate: component(x.aggregate, y.aggregate),
-            initialize: component(x.initialize, y.initialize),
-            select: component(x.select, y.select),
-            cancel: component(x.cancel, y.cancel),
-            call: component(x.call, y.call),
-            describe: component(x.describe, y.describe)
-        };
-    };
-    AgenticaTokenUsageAggregator.zero = () => {
-        const component = () => ({
-            total: 0,
-            input: {
-                total: 0,
-                cached: 0
-            },
-            output: {
-                total: 0,
-                reasoning: 0,
-                accepted_prediction: 0,
-                rejected_prediction: 0
-            }
-        });
-        return {
-            aggregate: component(),
-            initialize: component(),
-            select: component(),
-            cancel: component(),
-            call: component(),
-            describe: component()
-        };
-    };
-})(AgenticaTokenUsageAggregator || (AgenticaTokenUsageAggregator = {}));
+const 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;
+};
 
 class Agentica {
     constructor(props) {
@@ -10487,9 +11556,9 @@ class Agentica {
         this.listeners_ = new Map;
         this.prompt_histories_ = (props.histories ?? []).map((input => AgenticaPromptTransformer.transform({
             operations: this.operations_.group,
-            input
+            prompt: input
         })));
-        this.token_usage_ = AgenticaTokenUsageAggregator.zero();
+        this.token_usage_ = AgenticaTokenUsage.zero();
         this.ready_ = false;
         this.executor_ = typeof props.config?.executor === "function" ? props.config.executor : ChatGptAgent.execute(props.config?.executor ?? null);
     }
@@ -10500,12 +11569,17 @@ class Agentica {
         });
     }
     async conversate(content) {
-        const prompt = {
-            type: "text",
+        const prompt = new AgenticaTextPrompt({
             role: "user",
             text: content
-        };
-        await this.dispatch(prompt);
+        });
+        await this.dispatch(new AgenticaTextEvent({
+            role: "user",
+            stream: StreamUtil.to(content),
+            done: () => true,
+            get: () => content,
+            join: () => Promise.resolve(content)
+        }));
         const newbie = await this.executor_(this.getContext({
             prompt,
             usage: this.token_usage_
@@ -10541,37 +11615,50 @@ class Agentica {
             ready: () => this.ready_,
             prompt: props.prompt,
             dispatch: event => this.dispatch(event),
-            request: async (kind, body) => {
-                const event = {
-                    type: "request",
-                    source: kind,
+            request: async (source, body) => {
+                const event = new AgenticaRequestEvent({
+                    source,
                     body: {
                         ...body,
-                        model: this.props.vendor.model
+                        model: this.props.vendor.model,
+                        stream: true
                     },
                     options: this.props.vendor.options
-                };
+                });
                 await dispatch(event);
                 const completion = await this.props.vendor.api.chat.completions.create(event.body, event.options);
-                AgenticaTokenUsageAggregator.aggregate({
-                    kind,
-                    completion,
-                    usage: props.usage
-                });
+                const [streamForEvent, temporaryStream] = StreamUtil.transform(completion.toReadableStream(), (value => ChatGptCompletionMessageUtil.transformCompletionChunk(value))).tee();
+                const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+                void (async () => {
+                    const reader = streamForAggregate.getReader();
+                    while (true) {
+                        const chunk = await reader.read();
+                        if (chunk.done) break;
+                        if (chunk.value.usage) {
+                            AgenticaTokenUsageAggregator.aggregate({
+                                kind: source,
+                                completionUsage: chunk.value.usage,
+                                usage: props.usage
+                            });
+                        }
+                    }
+                })();
                 await dispatch({
                     type: "response",
-                    source: kind,
+                    source,
+                    stream: streamForEvent,
                     body: event.body,
                     options: event.options,
-                    value: completion
+                    join: async () => {
+                        const chunks = await StreamUtil.readAll(streamForEvent);
+                        return ChatGptCompletionMessageUtil.merge(chunks);
+                    }
                 });
-                return completion;
+                return streamForReturn;
             },
             initialize: async () => {
                 this.ready_ = true;
-                await dispatch({
-                    type: "initialize"
-                });
+                await dispatch(new AgenticaInitializeEvent);
             }
         };
     }
@@ -10599,5 +11686,5 @@ class Agentica {
     }
 }
 
-export { Agentica, createHttpLlmApplication };
+export { Agentica, AgenticaCallEvent, AgenticaCancelEvent, AgenticaCancelPrompt$1 as AgenticaCancelPrompt, AgenticaDescribeEvent, AgenticaDescribePrompt, AgenticaExecuteEvent, AgenticaExecutePrompt, AgenticaOperationSelection, AgenticaRequestEvent, AgenticaResponseEvent, AgenticaSelectEvent, AgenticaSelectPrompt, AgenticaTextEvent, AgenticaTextPrompt, AgenticaTokenUsage, createHttpLlmApplication };
 //# sourceMappingURL=index.mjs.map