@agentica/core 0.16.3 → 0.16.6

package/lib/index.mjs

@@ -4,10 +4,10 @@ import { v4 } from "uuid";
 
 import { HttpLlm, ChatGptTypeChecker, LlmTypeCheckerV3_1, OpenApi } from "@samchon/openapi";
 
-import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
-
 import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
 
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+
 import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 
 class AgenticaTokenUsage {
@@ -614,7 +614,8 @@ const ChatGptTokenUsageAggregator = {
 
 function transformCompletionChunk(source) {
     const str = source instanceof Uint8Array ? ByteArrayUtil.toUtf8(source) : source;
-    return (() => {
+    const result = JSON.parse(str);
+    const valid = (() => {
         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))));
@@ -627,394 +628,338 @@ function transformCompletionChunk(source) {
         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",
+        const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.id || _report(_exceptionable, {
             path: _path + ".id",
             expected: "string",
             value: input.id
-        }, _errorFactory)) && ((Array.isArray(input.choices) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), (Array.isArray(input.choices) || _report(_exceptionable, {
             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",
+        })) && input.choices.map(((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
             path: _path + ".choices[" + _index8 + "]",
             expected: "ChatCompletionChunk.Choice",
             value: elem
-        }, _errorFactory)) && _ao1(elem, _path + ".choices[" + _index8 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        })) && _vo1(elem, _path + ".choices[" + _index8 + "]", _exceptionable) || _report(_exceptionable, {
             path: _path + ".choices[" + _index8 + "]",
             expected: "ChatCompletionChunk.Choice",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             path: _path + ".choices",
             expected: "Array<ChatCompletionChunk.Choice>",
             value: input.choices
-        }, _errorFactory)) && ("number" === typeof input.created || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "number" === typeof input.created || _report(_exceptionable, {
             path: _path + ".created",
             expected: "number",
             value: input.created
-        }, _errorFactory)) && ("string" === typeof input.model || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "string" === typeof input.model || _report(_exceptionable, {
             path: _path + ".model",
             expected: "string",
             value: input.model
-        }, _errorFactory)) && ("chat.completion.chunk" === input.object || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "chat.completion.chunk" === input.object || _report(_exceptionable, {
             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",
+        }), null === input.service_tier || undefined === input.service_tier || "scale" === input.service_tier || "default" === input.service_tier || _report(_exceptionable, {
             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",
+        }), undefined === input.system_fingerprint || "string" === typeof input.system_fingerprint || _report(_exceptionable, {
             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",
+        }), null === input.usage || undefined === input.usage || ("object" === typeof input.usage && null !== input.usage || _report(_exceptionable, {
             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",
+        })) && _vo9(input.usage, _path + ".usage", _exceptionable) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo1 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.delta && null !== input.delta && false === Array.isArray(input.delta) || _report(_exceptionable, {
             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",
+        })) && _vo2(input.delta, _path + ".delta", _exceptionable) || _report(_exceptionable, {
             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",
+        }), 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 || _report(_exceptionable, {
             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",
+        }), "number" === typeof input.index || _report(_exceptionable, {
             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",
+        }), null === input.logprobs || undefined === input.logprobs || ("object" === typeof input.logprobs && null !== input.logprobs || _report(_exceptionable, {
             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",
+        })) && _vo6(input.logprobs, _path + ".logprobs", _exceptionable) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo2 = (input, _path, _exceptionable = true) => [ null === input.content || undefined === input.content || "string" === typeof input.content || _report(_exceptionable, {
             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",
+        }), undefined === input.function_call || ("object" === typeof input.function_call && null !== input.function_call && false === Array.isArray(input.function_call) || _report(_exceptionable, {
             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",
+        })) && _vo3(input.function_call, _path + ".function_call", _exceptionable) || _report(_exceptionable, {
             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",
+        }), null === input.refusal || undefined === input.refusal || "string" === typeof input.refusal || _report(_exceptionable, {
             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",
+        }), undefined === input.role || "assistant" === input.role || "user" === input.role || "developer" === input.role || "system" === input.role || "tool" === input.role || _report(_exceptionable, {
             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",
+        }), undefined === input.tool_calls || (Array.isArray(input.tool_calls) || _report(_exceptionable, {
             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",
+        })) && input.tool_calls.map(((elem, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
             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",
+        })) && _vo4(elem, _path + ".tool_calls[" + _index9 + "]", _exceptionable) || _report(_exceptionable, {
             path: _path + ".tool_calls[" + _index9 + "]",
             expected: "ChatCompletionChunk.Choice.Delta.ToolCall",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo3 = (input, _path, _exceptionable = true) => [ undefined === input.arguments || "string" === typeof input.arguments || _report(_exceptionable, {
             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",
+        }), undefined === input.name || "string" === typeof input.name || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo4 = (input, _path, _exceptionable = true) => [ "number" === typeof input.index || _report(_exceptionable, {
             path: _path + ".index",
             expected: "number",
             value: input.index
-        }, _errorFactory)) && (undefined === input.id || "string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), undefined === input.id || "string" === typeof input.id || _report(_exceptionable, {
             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",
+        }), undefined === input["function"] || ("object" === typeof input["function"] && null !== input["function"] && false === Array.isArray(input["function"]) || _report(_exceptionable, {
             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",
+        })) && _vo5(input["function"], _path + '["function"]', _exceptionable) || _report(_exceptionable, {
             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",
+        }), undefined === input.type || "function" === input.type || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo5 = (input, _path, _exceptionable = true) => [ undefined === input.arguments || "string" === typeof input.arguments || _report(_exceptionable, {
             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",
+        }), undefined === input.name || "string" === typeof input.name || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo6 = (input, _path, _exceptionable = true) => [ null === input.content || (Array.isArray(input.content) || _report(_exceptionable, {
             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",
+        })) && input.content.map(((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
             path: _path + ".content[" + _index10 + "]",
             expected: "ChatCompletionTokenLogprob",
             value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".content[" + _index10 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        })) && _vo7(elem, _path + ".content[" + _index10 + "]", _exceptionable) || _report(_exceptionable, {
             path: _path + ".content[" + _index10 + "]",
             expected: "ChatCompletionTokenLogprob",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             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",
+        }), null === input.refusal || (Array.isArray(input.refusal) || _report(_exceptionable, {
             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",
+        })) && input.refusal.map(((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
             path: _path + ".refusal[" + _index11 + "]",
             expected: "ChatCompletionTokenLogprob",
             value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".refusal[" + _index11 + "]", _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        })) && _vo7(elem, _path + ".refusal[" + _index11 + "]", _exceptionable) || _report(_exceptionable, {
             path: _path + ".refusal[" + _index11 + "]",
             expected: "ChatCompletionTokenLogprob",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo7 = (input, _path, _exceptionable = true) => [ "string" === typeof input.token || _report(_exceptionable, {
             path: _path + ".token",
             expected: "string",
             value: input.token
-        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), null === input.bytes || (Array.isArray(input.bytes) || _report(_exceptionable, {
             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",
+        })) && input.bytes.map(((elem, _index12) => "number" === typeof elem || _report(_exceptionable, {
             path: _path + ".bytes[" + _index12 + "]",
             expected: "number",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             path: _path + ".bytes",
             expected: "(Array<number> | null)",
             value: input.bytes
-        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "number" === typeof input.logprob || _report(_exceptionable, {
             path: _path + ".logprob",
             expected: "number",
             value: input.logprob
-        }, _errorFactory)) && ((Array.isArray(input.top_logprobs) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), (Array.isArray(input.top_logprobs) || _report(_exceptionable, {
             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",
+        })) && input.top_logprobs.map(((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
             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",
+        })) && _vo8(elem, _path + ".top_logprobs[" + _index13 + "]", _exceptionable) || _report(_exceptionable, {
             path: _path + ".top_logprobs[" + _index13 + "]",
             expected: "ChatCompletionTokenLogprob.TopLogprob",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo8 = (input, _path, _exceptionable = true) => [ "string" === typeof input.token || _report(_exceptionable, {
             path: _path + ".token",
             expected: "string",
             value: input.token
-        }, _errorFactory)) && (null === input.bytes || (Array.isArray(input.bytes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), null === input.bytes || (Array.isArray(input.bytes) || _report(_exceptionable, {
             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",
+        })) && input.bytes.map(((elem, _index14) => "number" === typeof elem || _report(_exceptionable, {
             path: _path + ".bytes[" + _index14 + "]",
             expected: "number",
             value: elem
-        }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }))).every((flag => flag)) || _report(_exceptionable, {
             path: _path + ".bytes",
             expected: "(Array<number> | null)",
             value: input.bytes
-        }, _errorFactory)) && ("number" === typeof input.logprob || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "number" === typeof input.logprob || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo9 = (input, _path, _exceptionable = true) => [ "number" === typeof input.completion_tokens || _report(_exceptionable, {
             path: _path + ".completion_tokens",
             expected: "number",
             value: input.completion_tokens
-        }, _errorFactory)) && ("number" === typeof input.prompt_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "number" === typeof input.prompt_tokens || _report(_exceptionable, {
             path: _path + ".prompt_tokens",
             expected: "number",
             value: input.prompt_tokens
-        }, _errorFactory)) && ("number" === typeof input.total_tokens || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "json.assertParse",
+        }), "number" === typeof input.total_tokens || _report(_exceptionable, {
             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",
+        }), undefined === input.completion_tokens_details || ("object" === typeof input.completion_tokens_details && null !== input.completion_tokens_details && false === Array.isArray(input.completion_tokens_details) || _report(_exceptionable, {
             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",
+        })) && _vo10(input.completion_tokens_details, _path + ".completion_tokens_details", _exceptionable) || _report(_exceptionable, {
             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",
+        }), undefined === input.prompt_tokens_details || ("object" === typeof input.prompt_tokens_details && null !== input.prompt_tokens_details && false === Array.isArray(input.prompt_tokens_details) || _report(_exceptionable, {
             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",
+        })) && _vo11(input.prompt_tokens_details, _path + ".prompt_tokens_details", _exceptionable) || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo10 = (input, _path, _exceptionable = true) => [ undefined === input.accepted_prediction_tokens || "number" === typeof input.accepted_prediction_tokens || _report(_exceptionable, {
             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",
+        }), undefined === input.audio_tokens || "number" === typeof input.audio_tokens || _report(_exceptionable, {
             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",
+        }), undefined === input.reasoning_tokens || "number" === typeof input.reasoning_tokens || _report(_exceptionable, {
             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",
+        }), undefined === input.rejected_prediction_tokens || "number" === typeof input.rejected_prediction_tokens || _report(_exceptionable, {
             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",
+        }) ].every((flag => flag));
+        const _vo11 = (input, _path, _exceptionable = true) => [ undefined === input.audio_tokens || "number" === typeof input.audio_tokens || _report(_exceptionable, {
             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",
+        }), undefined === input.cached_tokens || "number" === typeof input.cached_tokens || _report(_exceptionable, {
             path: _path + ".cached_tokens",
             expected: "(number | undefined)",
             value: input.cached_tokens
-        }, _errorFactory));
+        }) ].every((flag => flag));
         const __is = input => "object" === typeof input && null !== input && _io0(input);
-        let _errorFactory;
-        const __assert = (input, errorFactory) => {
+        let errors;
+        let _report;
+        return input => {
             if (false === __is(input)) {
-                _errorFactory = errorFactory;
-                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
-                    method: "json.assertParse",
+                errors = [];
+                _report = __typia_transform__validateReport._validateReport(errors);
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
                     path: _path + "",
-                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
+                    expected: "ChatCompletionChunk",
                     value: input
-                }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
-                    method: "json.assertParse",
+                })) && _vo0(input, _path + "", true) || _report(true, {
                     path: _path + "",
-                    expected: "ChatCompletionChunk & { usage: CompletionUsage | null | undefined; }",
+                    expected: "ChatCompletionChunk",
                     value: input
-                }, _errorFactory))(input, "$input", true);
+                }))(input, "$input", true);
+                const success = 0 === errors.length;
+                return success ? {
+                    success,
+                    data: input
+                } : {
+                    success,
+                    errors,
+                    data: input
+                };
             }
-            return input;
+            return {
+                success: true,
+                data: input
+            };
         };
-        return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
-    })()(str);
+    })()(result);
+    if (valid.success === false) {
+        console.error("Invalid ChatCompletionChunk", valid.errors);
+    }
+    return result;
 }
 
 function accumulate(origin, chunk) {
@@ -1202,19 +1147,19 @@ const StreamUtil = {
     transform: transform$1
 };
 
-async function cancelFunction(ctx, reference) {
+function cancelFunction(ctx, reference) {
     const index = ctx.stack.findIndex((item => item.operation.name === reference.name));
     if (index === -1) {
         return null;
     }
     const item = ctx.stack[index];
     ctx.stack.splice(index, 1);
-    await ctx.dispatch(createCancelEvent({
+    ctx.dispatch(createCancelEvent({
         selection: createOperationSelection({
             operation: item.operation,
             reason: reference.reason
         })
-    }));
+    })).catch((() => {}));
     return item;
 }
 
@@ -1278,24 +1223,19 @@ async function call(ctx, operations) {
                         value: execute.value
                     })).catch((() => {}));
                     if (isAgenticaContext(ctx)) {
-                        await cancelFunction(ctx, {
+                        cancelFunction(ctx, {
                             name: call.operation.name,
                             reason: "completed"
                         });
-                        ctx.dispatch(createCancelEvent({
-                            selection: createOperationSelection({
+                        return [ execute, createCancelHistory({
+                            id: call.id,
+                            selections: [ createOperationSelection({
                                 operation: call.operation,
                                 reason: "complete"
-                            })
-                        })).catch((() => {}));
+                            }) ]
+                        }) ];
                     }
-                    return [ execute, createCancelHistory({
-                        id: call.id,
-                        selections: [ createOperationSelection({
-                            operation: call.operation,
-                            reason: "complete"
-                        }) ]
-                    }) ];
+                    return [ execute ];
                 }));
             }
         }
@@ -1605,6 +1545,7 @@ const CONTAINER$1 = {
 };
 
 async function cancel(ctx) {
+    console.error("orchestrate.cancel");
     if (ctx.operations.divided === undefined) {
         return step$1(ctx, ctx.operations.array, 0);
     }
@@ -1629,7 +1570,7 @@ async function cancel(ctx) {
     for (const e of events) {
         if (e.type === "select") {
             collection.selections.push(e.selection);
-            await cancelFunction(ctx, {
+            cancelFunction(ctx, {
                 name: e.selection.operation.name,
                 reason: e.selection.reason
             });
@@ -1794,7 +1735,7 @@ async function step$1(ctx, operations, retry, failures) {
                     selections: []
                 });
                 for (const reference of input.functions) {
-                    const operation = await cancelFunction(ctx, reference);
+                    const operation = cancelFunction(ctx, reference);
                     if (operation !== null) {
                         collection.selections.push(operation);
                     }
@@ -4105,12 +4046,6 @@ function execute(executor) {
             const prompts = await (executor?.call ?? call)(ctx, ctx.stack.map((s => s.operation)));
             histories.push(...prompts);
             const executes = prompts.filter((prompt => prompt.type === "execute"));
-            for (const e of executes) {
-                await cancelFunction(ctx, {
-                    reason: "completed",
-                    name: e.operation.name
-                });
-            }
             histories.push(...await (executor?.describe ?? describe)(ctx, executes));
             if (executes.length === 0 || ctx.stack.length === 0) {
                 break;